其他分享
首页 > 其他分享> > 深入理解 Spring 事件发布与监听

深入理解 Spring 事件发布与监听

作者：互联网

在使用 Spring 构建的应用程序中，适当使用事件发布与监听的机制可以使我们的代码灵活度更高，降低耦合度。

在使用 Spring 构建的应用程序中，适当使用事件发布与监听的机制可以使我们的代码灵活度更高，降低耦合度。Spring 提供了完整的事件发布与监听模型，在该模型中，事件发布方只需将事件发布出去，无需关心有多少个对应的事件监听器；监听器无需关心是谁发布了事件，并且可以同时监听来自多个事件发布方发布的事件，通过这种机制，事件发布与监听是解耦的。

本节将举例事件发布与监听的使用，并介绍内部实现原理。

事件发布监听例子

新建 springboot 应用，boot 版本 2.4.0，引入如下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

自定义事件

Spring 中使用 ApplicationEvent 接口来表示一个事件，所以我们自定义事件 MyEvent 需要实现该接口：

public class MyEvent extends ApplicationEvent {
   
    public MyEvent(Object source) {
        super(source);
    }
}

构造器 source 参数表示当前事件的事件源，一般传入 Spring 的 context 上下文对象即可。

事件发布器

事件发布通过事件发布器 ApplicationEventPublisher 完成，我们自定义一个事件发布器 MyEventPublisher：

@Component
public class MyEventPublisher implements ApplicationEventPublisherAware, ApplicationContextAware {

    private ApplicationContext applicationContext;
    private ApplicationEventPublisher applicationEventPublisher;

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishEvent() {
        logger.info("开始发布自定义事件MyEvent");
        MyEvent myEvent = new MyEvent(applicationContext);
        applicationEventPublisher.publishEvent(myEvent);
        logger.info("发布自定义事件MyEvent结束");
    }
}

在自定义事件发布器 MyEventPublisher 中，我们需要通过 ApplicationEventPublisher 来发布事件，所以我们实现了 ApplicationEventPublisherAware 接口，通过回调方法 setApplicationEventPublisher 为 MyEventPublisher 的 ApplicationEventPublisher 属性赋值；同样的，我们自定义的事件 MyEvent 构造函数需要传入 Spring 上下文，所以 MyEventPublisher 还实现了 ApplicationContextAware 接口，注入了上下文对象 ApplicationContext。

publishEvent 方法发布了一个自定义事件 MyEvent。事件发布出去后，我们接着编写相应的事件监听器。

注解监听

我们可以方便地通过 @EventListener 注解实现事件监听，编写 MyEventPublisher：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener
    public void onMyEventPublished(MyEvent myEvent) {
        logger.info("收到自定义事件MyEvent -- MyAnnotationEventListener");
    }
}

被 @EventListener 注解标注的方法入参为 MyEvent 类型，所以只要 MyEvent 事件被发布了，该监听器就会起作用，即该方法会被回调。

编程实现监听

除了使用 @EventListener 注解实现事件的监听外，我们也可以手动实现 ApplicationListener 接口来实现事件的监听（泛型为监听的事件类型）：

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void onApplicationEvent(MyEvent event) {
        logger.info("收到自定义事件MyEvent");
    }
}

测试

在 springboot 的入口类中测试事件的发布：

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
        MyEventPublisher publisher = context.getBean(MyEventPublisher.class);
        publisher.publishEvent();
    }
}

运行程序，输出如下：

2020-06-22 16:31:46.667  INFO 83600 --- [           main] c.m.demo.publisher.MyEventPublisher      : 开始发布自定义事件MyEvent
2020-06-22 16:31:46.668  INFO 83600 --- [           main] cc.mrbird.demo.listener.MyEventListener  : 收到自定义事件MyEvent
2020-06-22 16:31:46.668  INFO 83600 --- [           main] c.m.d.l.MyAnnotationEventListener        : 收到自定义事件MyEvent -- MyAnnotationEventListener
2020-06-22 16:31:46.668  INFO 83600 --- [           main] c.m.demo.publisher.MyEventPublisher      : 发布自定义事件MyEvent结束

可以看到，两个监听器都监听到了事件的发布。此外细心的读者会发现，事件发布和事件监听是同一个线程完成的，过程为同步操作，只有当所有对应事件监听器的逻辑执行完毕后，事件发布方法才能出栈。后面进阶使用会介绍如何使用异步的方式进行事件监听。

事件发布监听原理

事件发布监听过程

在事件发布方法上打个断点：

在这里插入图片描述

以 debug 的方式启动程序，程序执行到该断点后点击 Step Into 按钮，程序跳转到 AbstractApplicationContext 的 publishEvent(ApplicationEvent event) 方法：

img

继续点击 Step Into，程序跳转到 AbstractApplicationContext 的 publishEvent(Object event, @Nullable ResolvableType eventType) 方法：

img

  1. getApplicationEventMulticaster 方法用于获取广播事件用的多播器，源码如下所示：

    img

    那么 AbstractApplicationContext 的 applicationEventMulticaster 属性是何时赋值的呢，下面将会介绍到。

  2. 获取到事件多播器后，调用其 multicastEvent 方法广播事件，点击 Step Into 进入该方法内部查看具体逻辑：

    img

    查看 invokeListener 方法源码：

    img

    继续查看 doInvokeListener 方法源码：

    img

上述过程就是整个事件发布与监听的过程。

多播器创建过程

为了弄清楚 AbstractApplicationContext 的 applicationEventMulticaster 属性是何时赋值的（即事件多播器是何时创建的），我们在 AbstractApplicationContext 的 applicationEventMulticaster 属性上打个断点：

img

以 debug 的方式启动程序，程序跳转到了 AbstractApplicationContext 的 initApplicationEventMulticaster 方法中：

img

通过跟踪方法调用栈，我们可以总结出程序执行到上述截图的过程：

  1. SpringBoot 入口类的 main 方法执行 SpringApplication.run(MyApplication.class, args) 启动应用：

    img

  2. run 方法内部包含 refreshContext 方法（刷新上下文）：

    img

  3. refresh 方法内部包含 initApplicationEventMulticaster 方法：

    img

  4. initApplicationEventMulticaster 方法创建多播器。

监听器获取过程

在追踪事件发布与监听的过程中，我们知道事件对应的监听器是通过 getApplicationListeners 方法获取的：

img

方法返回三个 MyEvent 事件对应的监听器，索引为 0 的监听器为 DelegatingApplicationListener，它没有实质性的处理某事件，忽略；索引为 1 的监听器为通过实现 ApplicationEventListener 接口的监听器；索引为 2 的监听器为通过 @EventListener 实现的监听器。

编程实现监听器注册过程

查看 getApplicationListeners 源码：

img

其中 retrieverCache 的定义为final Map<ListenerCacheKey, CachedListenerRetriever> retrieverCache = new ConcurrentHashMap<>(64)。

接着查看 retrieveApplicationListeners 方法（方法见名知意，程序第一次获取事件对应的监听器时，缓存中是空的，所以继续检索获取事件对应的监听器）：

img

从上面这段代码我们知道，用于遍历的监听器集合对象 listeners 和 listenerBeans 的值是从 this.defaultRetriever 的 applicationListeners 和 applicationListenerBeans 属性获取的，所以我们需要关注这些属性是何时被赋值的。defaultRetriever 的类型为 DefaultListenerRetriever：

img

我们在 applicationListeners 属性上右键选择 Find Usages 查看赋值相关操作：

img

可以看到，赋值操作发生在 AbstractApplicationEventMulticaster 的 addApplicationListener 方法中，

继续在 addApplicationListener 方法上右键选择 Find Usages 查看调用源：

img

我们在 registerListeners 方法上打个断点，重新启动程序，查看方法调用栈：

img

从方法调用栈我们可以总结出 this.defaultRetriever 的 applicationListeners 和 applicationListenerBeans 属性值赋值的过程：

  1. SpringApplication.run(MyApplication.class, args)启动 Boot 程序；

  2. run方法内部调用refreshContext刷新容器方法：

    img

  3. refresh方法内部调用了registerListener方法注册监听器：

    img

  4. registerListeners方法内部从 IOC 容器获取所有 ApplicationListener 类型 Bean，然后赋值给 this.defaultRetriever 的 applicationListeners 和 applicationListenerBeans 属性。

注解监听器注册过程

查看@EventListener注解源码：

img

查看 EventListenerMethodProcessor 源码：

img

其实现了 SmartInitializingSingleton 接口，该接口包含 afterSingletonsInstantiated 方法：

img

通过注释可以看到这个方法的调用时机为：单实例 Bean 实例化后被调用，此时 Bean 已经被创建出来。

我们查看 EventListenerMethodProcessor 是如何实现该方法的：

img

继续查看 processBean 方法源码：

img

至此，两种方式注册监听器的原理都搞清楚了。

使用进阶与拓展

事件监听异步化

通过前面的分析，我们知道事件广播和监听是一个线程完成的同步操作，有时候为了让广播更有效率，我们可以考虑将事件监听过程异步化。

单个异步

先来看看如何实现单个监听器异步。

首先需要在 springboot 入口类上通过@EnableAsync注解开启异步，然后在需要异步执行的监听器方法上使用@Async注解标注，以 MyAnnotationEventListener 为例：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Async // 异步
    @EventListener
    public void onMyEventPublished(MyEvent myEvent) {
        logger.info("收到自定义事件MyEvent -- MyAnnotationEventListener");
    }
}

启动程序，输出如下：

img

通过日志可以看出来，该监听器方法已经异步化，执行线程为 task-1。

整体异步

通过前面源码分析，我们知道多播器在广播事件时，会先判断是否有指定 executor，有的话通过 executor 执行监听器逻辑。所以我们可以通过指定 executor 的方式来让所有的监听方法都异步执行：

img

新建一个配置类：

@Configuration
public class AsyncEventConfigure {

    @Bean(name = AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME)
    public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
        SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
        eventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
        return eventMulticaster;
    }
}

在配置类中，我们注册了一个名称为 AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME（即 applicationEventMulticaster）的 Bean，用于覆盖默认的事件多播器，然后指定了 TaskExecutor，SimpleAsyncTaskExecutor 为 Spring 提供的异步任务 executor。

在启动项目前，先把之前在 springboot 入口类添加的@EnableAsync注解去掉，然后启动项目，输出如下：

img

可以看到，监听器事件都异步化了。

多事件监听器

事件监听器除了可以监听单个事件外，也可以监听多个事件（仅 @EventListener 支持），修改 MyAnnotationEventListener：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class, ContextRefreshedEvent.class, ContextClosedEvent.class})
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件");
        }
        if (event instanceof ContextRefreshedEvent) {
            logger.info("监听到ContextRefreshedEvent事件");
        }
        if (event instanceof ContextClosedEvent) {
            logger.info("监听到ContextClosedEvent事件");
        }
    }
}

该监听器将同时监听 MyEvent、ContextRefreshedEvent 和 ContextClosedEvent 三种类型事件：

img

监听器排序

单个类型事件也可以有多个监听器同时监听，这时候可以通过实现 Ordered 接口实现排序（或者 @Order 注解标注）。

修改 MyEventListener：

@Component
public class MyEventListener implements ApplicationListener<MyEvent>, Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void onApplicationEvent(MyEvent event) {
        logger.info("收到自定义事件MyEvent，我的优先级较高");
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

修改 MyAnnotationEventListener：

@Component
public class MyAnnotationEventListener implements Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class})
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件，我的优先级较低");
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

启动程序输出如下：

img

配合 SpEL 表达式

@EventListener 注解还包含一个 condition 属性，可以配合 SpEL 表达式来条件化触发监听方法。修改 MyEvent，添加一个 boolean 类型属性：

public class MyEvent extends ApplicationEvent {
    
    private boolean flag;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public MyEvent(Object source) {
        super(source);
    }
}

在发布事件的时候，将该属性设置为 false：

@Component
public class MyEventPublisher implements ApplicationEventPublisherAware, ApplicationContextAware {

    private ApplicationContext applicationContext;
    private ApplicationEventPublisher applicationEventPublisher;

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishEvent() {
        logger.info("开始发布自定义事件MyEvent");
        MyEvent myEvent = new MyEvent(applicationContext);
        myEvent.setFlag(false); // 设置为false
        applicationEventPublisher.publishEvent(myEvent);
        logger.info("发布自定义事件MyEvent结束");
    }
}

在 MyAnnotationEventListener 的 @EventListener 注解上演示如何使用 SpEL：

@Component
public class MyAnnotationEventListener implements Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class}, condition = "#event.flag")
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件，我的优先级较低");
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

condition = "#event.flag"的含义为，当前 event 事件（这里为 MyEvent）的 flag 属性为 true 的时候执行。

启动程序，输出如下：

img

因为我们发布的 MyEvent 的 flag 属性值为 false，所以上面这个监听器没有被触发。

事务事件监听器

Spring 4.2 开始提供了一个 @TransactionalEventListener 注解用于监听数据库事务的各个阶段：

  1. AFTER_COMMIT - 事务成功提交；
  2. AFTER_ROLLBACK – 事务回滚后；
  3. AFTER_COMPLETION – 事务完成后（无论是提交还是回滚）；
  4. BEFORE_COMMIT - 事务提交前；

例子：

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void onTransactionChange(ApplicationEvent event){
    logger.info("监听到事务提交事件");
}

标签：Spring,public,深入,事件,监听器,logger,监听,MyEvent
来源： https://blog.csdn.net/mbh12333/article/details/118085149