前言

上一篇介绍了国际化的使用以及初始化消息源的源码，接下来接着往下阅读，将进入 initApplicationEventMulticaster 、onRefresh 和 registerListeners 的相关操作逻辑。
这一部分主要是初始化事件广播器以及注册监听器。而 onRefresh 部分则需要子类去实现。 所以本文主要介绍以下几个部分：

  1. 什么是 Spring 事件？
  2. 监听器是如何使用的？

    什么是 Spring 事件？

    14-Spring initApplicationEventMulticaster - 图1
    这块的介绍在官网 1.15.2. Standard and Custom Events 部分有介绍。

    Spring 通过 ApplicationEvent 类和 ApplicationListener 接口提供 ApplicationContext 中的事件处理。如果将实现 ApplicationListener 接口的 bean 部署到上下文中，则每次将 ApplicationEvent 发布到 ApplicationContext 时，都会通知该 bean。本质上，这是标准的观察者设计模式。

归纳下来主要就是三个部分: 事件、事件发布者、事件监听器。

  1. 事件：ApplicationEvent，要自定义事件，则需要创建一个类继承 ApplicationEvent。
  2. 事件发布者：ApplicationEventPublisher 和 ApplicationEventMulticaster，因为 ApplicationContext 实现了 ApplicationEventPublisher，所以事件发布可以直接使用 ApplicationContext。
  3. 事件监听器：ApplicationListener，通过创建一个实现了 ApplicationListener 并注册为 Spring bean 的类来接收消息。

Spring 也提供了也有一些内置的监听器，可以在官网查看，这里就不做介绍了。

使用监听器

简单来说主要分为以下几个部分：

  1. 注册事件
  2. 注册监听器
  3. 发布事件

在接口调用发布事件时，监听器就会做出相应的操作。

1. 注册事件

创建 MyApplicationEvent 类并继承 ApplicationEvent

  1. public class MyApplicationEvent extends ApplicationEvent {
  2.     private static final long serialVersionUID = 5366526231219883438L;
  3.     private String message;
  4.     /**
  5.      * Create a new {@code ApplicationEvent}.
  6.      *
  7.      * @param source the object on which the event initially occurred or with
  8.      *               which the event is associated (never {@code null})
  9.      */
  10.     public MyApplicationEvent(Object source, String message) {
  11.         super(source);
  12.         this.message = message;
  13.     }
  14.     public String getMessage() {
  15.         return message;
  16.     }
  17. }

2. 注册监听器

  1. @Component
  2. public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {
  3.     @Override
  4.     public void onApplicationEvent(MyApplicationEvent event) {
  5.         System.out.println("MyApplicationListener 收到消息: " + event.getMessage());
  6.     }
  7. }

当然这里也可以使用注解 @EventListener 的方式来使用。

  1. @Component
  2. public class MyAnnotationApplicationListener {
  3.     @EventListener(classes = MyApplicationEvent.class)
  4.     public void myApplicationEventListener(MyApplicationEvent event) {
  5.         System.out.println("使用注解的方式, 收到事件: " + event.getMessage());
  6.     }
  7. }

3. 使用

因为 AnnotationConfigApplicationContext 实现了 ApplicationContext ， 而 ApplicationContext 实现了 ApplicationEventPublisher，所以这块传入当前 context 是没有问题的。

  1. public class AnnotationConfigApplicationTest {
  2.     public static void main(String[] args) {
  3.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
  4.         context.register(JavaConfig.class);
  5.         context.refresh();
  6.         MyApplicationEvent myApplicationEvent = new MyApplicationEvent(context, "呼叫土豆,呼叫土豆!");
  7.         context.publishEvent(myApplicationEvent);
  8.     }
  9. }

日志输出：
14-Spring initApplicationEventMulticaster - 图2

源码部分

initApplicationEventMulticaster

这块和上面初始化消息源类似，都是查找指定名称的 Bean ，如果找不到，则自己使用默认的。

  1. protected void initApplicationEventMulticaster() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     // 是否包含 applicationEventMulticaster Bean
  4.     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  5.         this.applicationEventMulticaster =
  6.                 beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  7.         if (logger.isTraceEnabled()) {
  8.             logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  9.         }
  10.     }
  11.     else {
  12.         // 使用  SimpleApplicationEventMulticaster 创建一个 事件发布器
  13.         SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  14.         simpleApplicationEventMulticaster.setApplicationStartup(getApplicationStartup());
  15.         this.applicationEventMulticaster = simpleApplicationEventMulticaster;
  16.         beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  17.         if (logger.isTraceEnabled()) {
  18.             logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
  19.                     "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
  20.         }
  21.     }
  22. }

onRefresh

这块需要子类去实现，我这里通过断电，暂时没有进去。所以就不介绍了。

registerListeners

  1. protected void registerListeners() {
  2.     // 添加实现ApplicationListener作为侦听器的bean。
  3.     // 不会影响其他侦听器，可以将它们添加为非bean。
  4.     // Register statically specified listeners first.
  5.     // 先注册静态指定的监听器
  6.     for (ApplicationListener<?> listener : getApplicationListeners()) {
  7.         getApplicationEventMulticaster().addApplicationListener(listener);
  8.     }
  9.     // Do not initialize FactoryBeans here: We need to leave all regular beans
  10.     // uninitialized to let post-processors apply to them!
  11.     // 只是添加 并没有执行
  12.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  13.     for (String listenerBeanName : listenerBeanNames) {
  14.         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  15.     }
  16.     // Publish early application events now that we finally have a multicaster...
  17.     // 发布早期的时间,并且将 earlyApplicationEvents 设置为空
  18.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  19.     this.earlyApplicationEvents = null;
  20.     if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
  21.         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
  22.             getApplicationEventMulticaster().multicastEvent(earlyEvent);
  23.         }
  24.     }
  25. }

总结

这篇文章主要内容是介绍 Spring 事件的使用，同时简单介绍了 initApplicationEventMulticaster 、onRefresh 和 registerListeners 部分的源码。
14-Spring initApplicationEventMulticaster - 图3

相关推荐