AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

事件的力量：探索Spring框架中的事件处理机制

2024-04-11 77
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 事件的力量：探索Spring框架中的事件处理机制

欢迎来到我的博客，代码的世界里，每一行都是一个故事

事件的力量：探索Spring框架中的事件处理机制


前言

在现代应用程序中，各个组件之间的通信是至关重要的。想象一下，你的应用程序中的各个模块像是一个巨大的交响乐团，每个模块都是一位音乐家，而Spring事件机制就像是指挥家，将所有音乐家协调得天衣无缝。这种松耦合的通信方式使你的应用程序更加灵活、可维护，而且能够轻松应对变化。现在，让我们进入这个令人兴奋的音乐厅，探索Spring事件的世界。

什么是spring事件

在Spring框架中，事件（Events）是一种基本概念，用于实现松耦合的通信方式，允许不同组件之间进行相互通知和协作。Spring事件机制允许应用程序内的组件发送和接收事件，以便在系统中实现更松散的耦合，同时提高了可维护性和可扩展性。

以下是有关Spring事件的基本概念和工作原理：

1. 事件（Event）：

  • 事件是一个对象，它封装了有关事件发生的信息。在Spring中，通常是一个普通的Java对象。
  • 事件可以包含任何有关事件的信息，例如事件类型、时间戳、发生事件的对象等。

2. 事件发布者（Event Publisher）：

  • 事件发布者是一个组件，它负责发出事件。
  • 事件发布者将事件通知给已注册的事件监听器。

3. 事件监听器（Event Listener）：

  • 事件监听器是接收和处理事件的组件。
  • 事件监听器订阅了特定类型的事件，并在事件发生时执行相应的操作。
  • 事件监听器是独立于事件发布者的，这意味着它们可以由不同的组件创建和管理，实现了松耦合。

4. Spring事件的工作原理：

  • 事件发布者将事件发布到Spring的应用程序上下文（ApplicationContext）。
  • 应用程序上下文将事件传递给所有已注册的事件监听器。
  • 事件监听器接收事件并执行相应的操作。

5. 使用场景：

  • Spring事件机制在各种场景下非常有用，包括：
  • 监听应用程序生命周期事件，如应用程序启动和关闭。
  • 监听领域对象的状态变化，例如数据库记录的更改。
  • 在分布式系统中实现事件驱动的通信。
  • 在模块之间进行解耦和通信。

6. 使用示例：

  • 示例代码如下，演示了如何使用Spring事件机制：
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("Received MyEvent: " + event.getMessage());
    }
    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        System.out.println("Context is refreshed.");
    }
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        context.start();
        // 发布自定义事件
        context.publishEvent(new MyEvent("Hello, Spring Events!"));
        context.stop();
    }
}
class MyEvent extends ApplicationEvent {
    private final String message;
    public MyEvent(String message) {
        super(message);
        this.message = message;
    }
    public String getMessage() {
        return message;
    }
}

在上述示例中，MyEventListener是一个事件监听器，它监听了自定义事件MyEvent。当MyEvent被发布时，监听器会接收并处理该事件。

总之，Spring事件是一种强大的松耦合通信机制，允许不同组件之间进行相互通知和协作，从而提高了应用程序的可扩展性和可维护性。

事件发布与监听

在Spring中，事件的发布和监听是通过Spring的ApplicationEventPublisher接口和事件监听器来实现的。以下是如何在Spring中发布事件以及如何编写事件监听器来处理这些事件的步骤：

1. 发布事件：

首先，您需要获取ApplicationEventPublisher对象，并使用它来发布事件。您可以在Spring组件（例如服务类、控制器、应用程序启动类等）中注入ApplicationEventPublisher。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class MyService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void performSomeAction() {
        // 创建并发布自定义事件
        MyCustomEvent customEvent = new MyCustomEvent(this, "Some event data");
        eventPublisher.publishEvent(customEvent);
    }
}

2. 创建自定义事件：

您需要创建一个继承自ApplicationEvent的自定义事件类，并定义事件的数据。

import org.springframework.context.ApplicationEvent;
public class MyCustomEvent extends ApplicationEvent {
    private final String eventData;
    public MyCustomEvent(Object source, String eventData) {
        super(source);
        this.eventData = eventData;
    }
    public String getEventData() {
        return eventData;
    }
}

3. 编写事件监听器：

事件监听器是处理事件的组件。您可以编写一个类并实现ApplicationListener接口，然后在类上使用@Component或注册为Spring Bean。

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class MyEventListener implements ApplicationListener<MyCustomEvent> {
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        // 处理自定义事件
        String eventData = event.getEventData();
        System.out.println("Received custom event: " + eventData);
    }
}

4. 触发事件：

在需要触发事件的地方，调用发布事件的方法。

@Service
public class MyService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void performSomeAction() {
        // 创建并发布自定义事件
        MyCustomEvent customEvent = new MyCustomEvent(this, "Some event data");
        eventPublisher.publishEvent(customEvent);
    }
}

5. 启用事件处理：

确保Spring的组件扫描配置正确，以便Spring能够扫描和识别事件监听器。通常，@ComponentScan注解在主配置类上用于扫描包含事件监听器的包。

@SpringBootApplication
@ComponentScan(basePackages = "com.example")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

6. 运行应用程序：

运行Spring应用程序，并在需要触发事件的地方调用相应的方法。事件监听器将会接收和处理事件。

public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
        // 在应用程序中触发事件
        MyService myService = applicationContext.getBean(MyService.class);
        myService.performSomeAction();
    }
}

以上是在Spring中发布事件以及编写事件监听器的基本步骤。使用事件发布和监听机制，不同的组件可以在应用程序中实现松耦合的通信，使得应用程序更加灵活和可维护。

自定义事件

要创建自定义事件以满足应用程序的特定需求，您需要按照以下步骤进行操作：

1. 创建自定义事件类：

首先，您需要创建一个继承自org.springframework.context.ApplicationEvent的自定义事件类。这个类将包含您希望在应用程序中传递的事件信息。您可以在自定义事件类中添加任何属性和方法，以满足您的需求。

例如，假设您要创建一个名为UserRegistrationEvent的自定义事件，用于表示用户注册事件，可以这样定义事件类：

import org.springframework.context.ApplicationEvent;
public class UserRegistrationEvent extends ApplicationEvent {
    private final String username;
    public UserRegistrationEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
    public String getUsername() {
        return username;
    }
}

在上述示例中，UserRegistrationEvent类包含了一个username属性，用于存储注册用户的用户名。

2. 发布自定义事件：

要发布自定义事件，您需要获取ApplicationEventPublisher对象并使用它来发布事件。这通常通过在需要发布事件的类中注入ApplicationEventPublisher来实现。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void registerUser(String username) {
        // 执行用户注册逻辑
        // ...
        // 发布自定义事件
        UserRegistrationEvent registrationEvent = new UserRegistrationEvent(this, username);
        eventPublisher.publishEvent(registrationEvent);
    }
}

在上述示例中，UserService类中的registerUser方法执行了用户注册逻辑，并在注册成功后发布了UserRegistrationEvent事件。

3. 创建事件监听器：

为了响应自定义事件，您需要创建一个事件监听器类，实现org.springframework.context.ApplicationListener接口，并在类中实现onApplicationEvent方法。

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class UserRegistrationListener implements ApplicationListener<UserRegistrationEvent> {
    @Override
    public void onApplicationEvent(UserRegistrationEvent event) {
        // 处理用户注册事件
        String username = event.getUsername();
        System.out.println("User registered: " + username);
    }
}

在上述示例中，UserRegistrationListener类监听UserRegistrationEvent事件，并在事件发生时执行相应的操作。

4. 注册事件监听器：

确保您的事件监听器被Spring识别和注册。通常，您可以通过将@Component或@Service注解添加到监听器类上，或者在配置类中注册监听器。

5. 触发自定义事件：

在需要触发自定义事件的地方，调用相应的方法来发布事件。在上述示例中，我们在UserService类的registerUser方法中发布了UserRegistrationEvent事件。

6. 运行应用程序：

最后，运行Spring应用程序，并在适当的地方触发自定义事件。事件监听器将会接收并处理事件。

通过上述步骤，您可以创建自定义事件以满足应用程序的特定需求，并使用Spring的事件机制进行通信和协作。这种机制可以帮助您实现组件之间的松耦合，并提高应用程序的可扩展性和可维护性。

异步事件处理

在Spring中实现异步事件处理可以提高应用程序的性能和响应速度，特别是在处理耗时的操作时。Spring提供了异步事件处理的支持，您可以使用@Async注解和TaskExecutor来实现异步事件监听器。

以下是实现异步事件处理的步骤：

1. 添加异步支持配置：

首先，确保您的Spring应用程序启用了异步支持。在配置类上添加@EnableAsync注解，这会告诉Spring启用异步处理。

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
@Configuration
@EnableAsync
public class AsyncConfig {
    // 其他配置
}

2. 创建异步事件监听器：

创建一个实现ApplicationListener接口的异步事件监听器。在需要异步处理的事件监听器方法上添加@Async注解。

import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
@Component
public class MyAsyncEventListener implements ApplicationListener<MyEvent> {
    @Async
    @Override
    public void onApplicationEvent(MyEvent event) {
        // 异步处理事件，可以是耗时的操作
        // ...
    }
}

在上面的示例中，@Async注解告诉Spring该方法应该在单独的线程中异步执行。

3. 发布事件：

在需要触发事件的地方，使用ApplicationEventPublisher发布事件，就像在同步事件处理中一样。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class MyService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void performSomeAction() {
        // 执行操作
        // 发布事件，会异步处理
        MyEvent customEvent = new MyEvent(this, "Some event data");
        eventPublisher.publishEvent(customEvent);
    }
}

4. 配置异步执行器（可选）：

如果需要更细粒度地配置异步执行器，可以定义一个TaskExecutor bean，并将其注入到Spring容器中。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
@Configuration
public class AsyncConfig {
    @Bean
    public TaskExecutor taskExecutor() {
        return new SimpleAsyncTaskExecutor(); // 使用默认的异步执行器
    }
}

您可以根据需要使用不同的TaskExecutor实现，以满足应用程序的性能需求。

5. 运行应用程序：

最后，运行Spring应用程序，并在需要触发事件的地方调用相应的方法。事件监听器方法将会异步执行。

通过上述步骤，您可以实现在Spring中异步处理事件，从而提高应用程序的性能和响应速度。异步事件处理特别适用于处理可能导致阻塞的长时间运行任务，如发送电子邮件、生成报告等操作。请注意，在使用异步事件处理时，要谨慎处理线程安全和异常处理，以确保应用程序的稳定性。

事件传播

在Spring框架中，事件传播（Event Propagation）是指事件在应用程序中传递的机制。Spring提供了不同的事件传播机制，允许您控制事件在应用程序中的传递路径。事件传播机制定义了事件发布后如何传递给事件监听器，以及是否允许事件监听器干预事件的传递。

以下是有关事件传播机制的详细解释：

1. Spring中的事件传播类型：

Spring框架定义了几种不同的事件传播类型，用于控制事件的传递路径。以下是最常见的事件传播类型：

  • Publish (ApplicationEventPublisher.publishEvent(event))： 这是最常见的事件传播类型，事件会被直接传递给所有已注册的监听器。如果一个监听器抛出异常，它将中断事件传播，但不会影响其他监听器。
  • Publish Async (ApplicationEventPublisher.publishEvent(event) + 异步执行)： 与Publish类似，但事件监听器会在异步线程中执行。这可以提高性能，但需要确保监听器是线程安全的。
  • Publish On Tx (ApplicationEventPublisher.publishEvent(event) + 事务内部)： 事件只有在事务内部才会被传播。如果没有活动的事务，则事件将不会传播。这用于确保事件与事务一致性。
  • Publish On Tx Commit (ApplicationEventPublisher.publishEvent(event) + 事务提交后)： 事件将在事务成功提交后才被传播。这用于确保事件在事务成功完成后才会被处理。

2. 控制事件传播类型：

您可以在发布事件时通过ApplicationEventPublisher的publishEvent(event)方法的重载来指定事件的传播类型。例如：

@Autowired
private ApplicationEventPublisher eventPublisher;
public void publishEvent(MyEvent event) {
    // Publish事件（默认传播类型）
    eventPublisher.publishEvent(event);
    // Publish Async事件
    eventPublisher.publishEvent(event, AsyncEventPublicationPolicy.ASYNC);
    // Publish On Tx事件
    eventPublisher.publishEvent(event, TransactionEventPublicationPolicy.PUBLISH_ON_TRANSACTION);
    // Publish On Tx Commit事件
    eventPublisher.publishEvent(event, TransactionEventPublicationPolicy.PUBLISH_AFTER_COMMIT);
}

通过使用不同的传播类型，您可以控制事件在应用程序中的传递路径。例如，如果希望事件在事务内部处理，可以使用Publish On Tx传播类型。

3. 事件监听器的顺序：

事件监听器的注册顺序也影响事件的传播路径。Spring允许您通过@Order注解或Ordered接口来控制事件监听器的执行顺序。可以通过设置@Order注解中的值或实现Ordered接口中的getOrder方法来指定监听器的执行顺序。

@Component
@Order(1) // 设置监听器的执行顺序
public class MyEventListener1 implements ApplicationListener<MyEvent> {
    // ...
}
@Component
@Order(2)
public class MyEventListener2 implements ApplicationListener<MyEvent> {
    // ...
}

通过设置@Order或实现Ordered接口，您可以确保事件监听器按照指定的顺序执行。

总之，Spring的事件传播机制允许您在应用程序中控制事件的传递路径，以及事件监听器的执行顺序。通过选择合适的事件传播类型和设置监听器的执行顺序，您可以实现更精确的事件处理逻辑，以满足应用程序的需求。这种机制有助于实现松耦合的组件通信和更高的灵活性。

条件事件监听

在Spring中，您可以使用条件事件监听器来根据条件来选择性地监听事件，以实现更灵活的事件处理。条件事件监听器允许您在监听事件之前进行条件检查，仅在条件满足时才执行监听器的操作。

以下是如何实现条件事件监听器的步骤：

1. 创建条件事件监听器：

首先，您需要创建一个事件监听器类，实现ApplicationListener接口。然后，您可以在监听器类中编写条件逻辑来控制何时执行事件监听器的操作。

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class ConditionalEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        // 检查条件是否满足
        if (conditionIsMet(event)) {
            // 执行事件处理逻辑
            // ...
        }
    }
    private boolean conditionIsMet(MyEvent event) {
        // 根据事件和其他条件来判断是否满足条件
        // 返回true表示满足条件，返回false表示不满足条件
        // 例如，可以检查事件中的数据或应用程序的状态等条件
        return event.getData() != null;
    }
}

在上面的示例中，ConditionalEventListener类的onApplicationEvent方法会首先检查条件是否满足，然后在条件满足时执行事件处理逻辑。

2. 发布事件：

在需要触发事件的地方，使用ApplicationEventPublisher发布事件，就像在常规事件处理中一样。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class MyService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void performSomeAction() {
        // 执行操作
        // 发布事件
        MyEvent customEvent = new MyEvent(this, "Some event data");
        eventPublisher.publishEvent(customEvent);
    }
}

3. 运行应用程序：

最后，运行Spring应用程序，并在需要触发事件的地方调用相应的方法。条件事件监听器会在条件满足时执行。

public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
        // 在应用程序中触发事件
        MyService myService = applicationContext.getBean(MyService.class);
        myService.performSomeAction();
    }
}

通过上述步骤，您可以实现条件事件监听，根据特定条件来选择性地执行事件监听器的操作。这允许您在事件处理中引入更多的灵活性和控制，以满足应用程序的需求。条件事件监听器可以帮助您根据不同的条件采取不同的处理方式，实现更多定制化的事件处理逻辑。

文章标签：
Java
Spring
安全
数据库
存储
关键词：
Spring机制
Spring框架
Spring事件
Spring框架事件处理机制
事件Spring
一只牛博
目录
相关文章
喜欢猪猪
|
18天前
|
XML 安全 Java
深度探索Spring Context：框架式的Bean访问与企业级功能
【12月更文挑战第1天】
喜欢猪猪
32 1
wljslmz
|
21天前
|
缓存 NoSQL Java
什么是缓存？如何在 Spring Boot 中使用缓存框架
什么是缓存？如何在 Spring Boot 中使用缓存框架
wljslmz
28 0
智物科技库
|
3天前
|
NoSQL Java Redis
Spring Boot 自动配置机制：从原理到自定义
Spring Boot 的自动配置机制通过 `spring.factories` 文件和 `@EnableAutoConfiguration` 注解，根据类路径中的依赖和条件注解自动配置所需的 Bean，大大简化了开发过程。本文深入探讨了自动配置的原理、条件化配置、自定义自动配置以及实际应用案例，帮助开发者更好地理解和利用这一强大特性。
智物科技库
37 14
蓝易云
|
4天前
|
IDE Java 测试技术
互联网应用主流框架整合之Spring Boot开发
通过本文的介绍，我们详细探讨了Spring Boot开发的核心概念和实践方法，包括项目结构、数据访问层、服务层、控制层、配置管理、单元测试以及部署与运行。Spring Boot通过简化配置和强大的生态系统，使得互联网应用的开发更加高效和可靠。希望本文能够帮助开发者快速掌握Spring Boot，并在实际项目中灵活应用。
蓝易云
23 5
喜欢猪猪
|
14天前
|
缓存 Java 数据库连接
Spring框架中的事件机制：深入理解与实践
Spring框架是一个广泛使用的Java企业级应用框架，提供了依赖注入、面向切面编程（AOP）、事务管理、Web应用程序开发等一系列功能。在Spring框架中，事件机制是一种重要的通信方式，它允许不同组件之间进行松耦合的通信，提高了应用程序的可维护性和可扩展性。本文将深入探讨Spring框架中的事件机制，包括不同类型的事件、底层原理、应用实践以及优缺点。
喜欢猪猪
46 8
蓝易云
|
20天前
|
缓存 Java 数据库连接
深入探讨：Spring与MyBatis中的连接池与缓存机制
Spring 与 MyBatis 提供了强大的连接池和缓存机制，通过合理配置和使用这些机制，可以显著提升应用的性能和可扩展性。连接池通过复用数据库连接减少了连接创建和销毁的开销，而 MyBatis 的一级缓存和二级缓存则通过缓存查询结果减少了数据库访问次数。在实际应用中，结合具体的业务需求和系统架构，优化连接池和缓存的配置，是提升系统性能的重要手段。
蓝易云
35 4
潇洒洒
|
25天前
|
Java 开发者 Spring
深入解析：Spring AOP的底层实现机制
在现代软件开发中，Spring框架的AOP（面向切面编程）功能因其能够有效分离横切关注点（如日志记录、事务管理等）而备受青睐。本文将深入探讨Spring AOP的底层原理，揭示其如何通过动态代理技术实现方法的增强。
潇洒洒
52 8
dufadayang
|
24天前
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架，实现分布式事务的管理和处理。在实际应用中，还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时，要注意处理各种可能出现的问题，以保障分布式事务的顺利执行。
dufadayang
44 6
路卿老师
|
28天前
|
Java Kotlin 索引
学习Spring框架特性及jiar包下载
Spring 5作为最新版本，更新了JDK基线至8，修订了核心框架，增强了反射和接口功能，支持响应式编程及Kotlin语言，引入了函数式Web框架，并提升了测试功能。Spring框架可在其官网下载，包括文档、jar包和XML Schema文档，适用于Java SE和Java EE项目。
路卿老师
31 0
Love-Java.
|
Java Spring
spring框架之AOP模块(面向切面)，附带通知类型---超详细介绍
spring框架之AOP模块(面向切面)，附带通知类型---超详细介绍
Love-Java.
132 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Spring(二)之入门示例
  • 4
    spring入门
  • 5
    spring 拦截器
  • 6
    Reactive Spring实战——响应式MySql交互
  • 7
    Dubbo之——改造Dubbo，使其能够兼容Spring 4注解配置
  • 8
    Spring Cloud 统一配置
  • 9
    全栈开发实战｜​人事管理系统的设计与实现（Spring Boot + Vue 3 + MyBatis）
  • 10
    [Spring]支持注解的Spring调度器
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    95
  • 2
    Spring Boot中一般如何使用线程池？
    753
  • 3
    Spring Boot 源码面试知识点
    100
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    253
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot全局自定义异常
    44
  • 8
    RabbitMQ的springboot项目集成使用-01
    147
  • 9
    什么是Spring Boot 自动配置？
    60
  • 10
    Spring cloud原理详解
    79

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks