ApplicationEvent和ApplicationListener的在SpringBoot的应用

ApplicationEvent和ApplicationListener：

监听事件：ApplicationEvent

监听：ApplicationListener

SpringBoot中通过ApplicationListener去监听ApplicationEvent事件，做出对应的行为。

具体实现：

/**
 * 监听对象
 */
public class MyEvent extends ApplicationEvent {

    private String message;

    public MyEvent(Object source,String message) {
        super(source);
        this.message = message;
    }

    public String getMessage(){
        return message;
    }
}


/**
 * 监听方法一：
 */
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent myEvent) {

        System.out.println("接收到事件: " + myEvent.getMessage());
        // 模拟事件处理
        try {
            Thread.sleep(3000);
            System.out.println("正在处理出发后的业务逻辑。。。。。");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

/**
 * 监听方法二：
 * 通过注解的方式去监听事件。分别三种方式去监听事件
 */
@Component
public class MyEventListener{
    
    @EventListener // 监听MyEvent事件
    @EventListener(MyEvent.class) //监听事件为MyEvent的事件
    @EventListener(condition = "#event.message == 'hello1'") //通过SpEL表达式来匹配监听事件值为hello1的事件
    public void onApplicationEvent(MyEvent myEvent) {

        System.out.println("接收到事件: " + myEvent.getMessage());
        // 模拟事件处理
        try {
            Thread.sleep(3000);
            System.out.println("正在处理出发后的业务逻辑。。。。。");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

spring默认的监听都是串行的。即有多个监听方法监听同一个事件的时候，串行执行，方法一结束之后处理方法二。

通过@EnableAsync注解开启并行处理，并在方法上使用@Async注解进行并行执行。或者在SpringBoot上使用@EnableAsync开起并行处理，并在方法上使用@Async注解进行并行执行。

通过 @Order(5)注解来表明监听事件的执行顺序。数字越小，优先级越高。

@Configuration
@EnableAsync
public class MyConfig {
    // 配置类

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(500);
        executor.initialize();
        return executor;
    }
}

/**
 * 监听方法二
 */
@Component
public class MyEventListener{
    
    @Async
    @Order(5)
    @EventListener
    public void listener3(MyEvent event) throws InterruptedException {
        System.out.println("listener3" +System.currentTimeMillis());
        // 处理事件
        Thread.sleep(3000L);
        System.out.println("事件监听器 3 接收到事件: " + event.getMessage());
    }
}

SpringBoot中内置了很多监听事件（ApplicationEvent）

这些内置的可以让我们直接使用监听事件，编写对应的监听即可。

ApplicationStartingEvent：在 Spring Boot 应用程序启动之前发布。
ApplicationEnvironmentPreparedEvent：在 Spring Boot 应用程序的环境已经准备好，但正在创建 Application Context 上下文之前发布。
ApplicationContextInitializedEvent：当 Spring Boot 应用程序 Application Context 上下文准备就绪并且调用
ApplicationContextInitializers，但尚未加载 bean 定义时发布。
ApplicationPreparedEvent：在 Spring Boot 应用程序的 Application Context 上下文已经创建，但尚未刷新之前发布。
ApplicationStartedEvent：在 Spring Boot 应用程序的 Application Context 上下文已经刷新，但尚未启动之前发布。
ApplicationReadyEvent：在 Spring Boot 应用程序已经启动并准备接受请求之后发布。
ApplicationFailedEvent：在 Spring Boot 应用程序启动失败时发布。

SpringBoot的启动类的不同写法

/**
 * 方法一
 */
@SpringBootApplication
public class Nacos2Application {

    public static void main(String[] args) {
       SpringApplication.run(Nacos2Application.class);
    }
}

/**
 * 方法二
 */
@SpringBootApplication
public class Nacos2Application {

    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication(Nacos2Application.class);
        springApplication.addListeners(new SpringStartBeforeEventListener(),new SpringBootOverEventListener());
        springApplication.run(args);
    }
}


/**
 * 方法三
 */
@SpringBootApplication
public class Nacos2Application {

    public static void main(String[] args) {
        new SpringApplicationBuilder().sources(Nacos2Application.class)
                .listeners(new SpringStartBeforeEventListener())
                .run(args);
    }
}