深入理解Spring事件机制（一）：广播器与监听器的初始化

前言

Spring 从 3.x 开始支持事件机制。在 Spring 的事件机制中，我们可以令一个事件类继承 ApplicationEvent 类，然后将实现了 ApplicationListener 的 Bean 注册到 spring 容器，最后向 ApplicationEventPublisher 推送事件对象即可令所有订阅者收到事件。在 4.2 以后，甚至不需要实现 ApplicationListener 接口，仅需在 Bean 中方法标记 @EventListener 注解即可。

笔者将基于 Spring 源码的 5.2.x 分支，分析该功能是如何实现的。

本文是其中的第一篇文章，将分析广播器与监听的是如何被初始化，并完成注解流程的。

在开始前，推荐先阅读前文了解 Spring 容器的初始化过程与 BeanFactory 中 Bean 的创建，如果可能，还可以了解一点 Spring 的注解机制，这将更有利于流程与一些代码的理解。

相关文章：

• 深入理解Spring事件机制（一）：广播器与监听器的初始化
• 深入理解Spring事件机制（二）：事件的推送

一、广播器的创建

在前文，我们知道容器的初始化是通过 AbstractApplicationContext.refresh() 方法完成的，事件机制的相关组件同样也离不开容器，因此事件系统的初始化也通过该方法完成。

AbstractApplicationContext.initApplicationEventMulticaster() 是第一步，它的作用很简单：

如果当前 BeanFactory 有名为 “applicationEventMulticaster” 的 ApplicationEventMulticaster，就把它设置为当前上下文的事件广播器，否则就创建并在 BeanFactory 中注册一个SimpleApplicationEventMulticaster 实例作为当前上下文的事件广播器。

protected void initApplicationEventMulticaster() {     ConfigurableListableBeanFactory beanFactory = getBeanFactory();     // 是否存在“applicationEventMulticaster”这个Bean     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {         // 如果存在就把它设置为当前上下文的事件广播器         this.applicationEventMulticaster =             beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);         if (logger.isTraceEnabled()) {             logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");         }     }     else {         // 没有就创建一个SimpleApplicationEventMulticaster作为当前上下文的事件广播器         this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);         beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);         if (logger.isTraceEnabled()) {             logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +                          "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");         }     } } 

二、编程式监听器的注册

在 4.2 及以前版本，监听器需要显式的实现 ApplicationListener 接口，我们管这种监听器叫做编程式监听器。

编程式监听器在 AbstractApplicationContext.registerListeners() 这个方法的调用过程中被注册到注册广播器中，这一块代码逻辑也很简单：

• 向事件广播器注册已经被注册的 BeanFactroy 中，且实现了 ApplicationListener 接口的监听器；
• 向事件广播器注册还没有被实例化的监听器的 BeanName；
• 发布一些早期事件；

protected void registerListeners() {     // 向事件广播器注册已经被注册的上下文中的监听器     for (ApplicationListener<?> listener : getApplicationListeners()) {         getApplicationEventMulticaster().addApplicationListener(listener);     }      // 向事件广播器注册指定的监听器，不过这里只注册BeanName，     // 因为有些监听器Bean是由FactoryBean生产的，而在这里FactoryBean实际上还没被生成出来     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);     for (String listenerBeanName : listenerBeanNames) {         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);     }      // 发布一些早期事件     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;     this.earlyApplicationEvents = null;     if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {             getApplicationEventMulticaster().multicastEvent(earlyEvent);         }     } } 

我们需要注意的是，在这一步，虽然向广播器注册了监听器，但是实际上这只是一种关系，真正的监听器实例不一定有被创建出来。

不过在如果上下文中存在“早期事件”，则会触发广播，此时调用 ApplicationEventMulticaster.multicastEvent() 将会提前触发广播器中那些监听器的初始化，否则按正常情况这些将等到上下文主动初始化 BeanFactory 中全部非懒加载 Bean 的时候才会一并初始化。

三、注解式监听器的注册

在 4.2 版本以后，我们可以通过在成员方法上添加 @EventListener 或者 @TransactionalEventListener 注解的方法声明一个监听器，我们管这种监听器叫做注解式监听器。

实际上，由于注解式监听器的类上没有注解或接口作为标识，因此无法直接从 BeanFactory 中查找，所以它的注册显然不能与编程式监听器一样，在 AbstractApplicationContext.registerListeners() 通过从 BeanFactory 中直接找到然后注册。

和 3.0 以后支持的一些注解式配置的原理一样，@EventListener 是通过 EventListenerMethodProcessor 这个特殊的后置处理器完成注册的。

EventListenerMethodProcessor 实现的接口如下：

public class EventListenerMethodProcessor     implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor { } 

其中， SmartInitializingSingleton 和 BeanFactoryPostProcessor 接口非常直观的告诉了我们它被调用的时机：

• BeanFactoryPostProcessor：在上下文初始化的时候，通过 AbstractApplicationContext.invokeBeanFactoryPostProcessors 这个方法跟其他 BeanFactory 的后置处理器被一起集中调用；
• SmartInitializingSingleton：在这个 Bean 完成初始化的时候；

接下来我们通过处理器分析注解式监听器的注册流程。

1、监听器方法处理器的注册

根据前文，我们知道容器在初始化过程中，通过 AbstarctApplicationContext.obtainFreshBeanFactory 创建新 BeanFactory 的时候，最终会一路绕到 AbstractRefreshableApplicationContext.loadBeanDefinitions 这个方法上，通过这个方法上下文会为自己的 BeanFactory 提前加载好 BeanDefinition。

而这个抽象方法在不同的上下文会有不同的实现，但是基本都要通过不同的 BeanDefinitionReader 去完成这个过程。

支持注解式配置的上下文会用 AnnotatedBeanDefinitionReader 去读取配置的时候，会通过 AnnotationConfigBeanDefinitionParser 将配置信息解析为具体的 BeanDefinition 。而 Spring 就在这一步将默认配置的一些 Bean 的 BeanDefinition 给加上了。

实际上，不止 EventListenerMethodProcessor ，几乎所有针对 Spring 注解的后置处理器都是通过这种方式注册到 BeanFactory 的。

具体代码参见 AnnotationConfigUtils.registerAnnotationConfigProcessors 方法：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(     BeanDefinitionRegistry registry, @Nullable Object source) {     // 其他的一些注解处理器，比如 @Configuration，@Autowrite 之类的注解处理器... ...          // 注册 EventListenerMethodProcessor     if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {         RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);         def.setSource(source);         beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));     }      // 注册名为“org.springframework.context.event.internalEventListenerFactory” EventListenerFactory     if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {    RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);    def.setSource(source);    beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));   }          return beanDefs; } 

2、获取监听器工厂

当 EventListenerMethodProcessor 被作为一个 BeanFactoryPostProcessor 被调用时，它会从 BeanFactory 中收集所有实现了 EventListenerFactory 接口的 Bean，然后记录在成员变量 eventListenerFactories 中：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {     this.beanFactory = beanFactory;     Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);     List<EventListenerFactory> factories = new ArrayList<>(beans.values());     AnnotationAwareOrderComparator.sort(factories);     this.eventListenerFactories = factories; } 

而监听器工厂这个类作用也显而易见，他用于把被注解的方法适配为监听器对象：

public interface EventListenerFactory {     // 是否支持处理该方法     boolean supportsMethod(Method method);     // 将bean中带有@EventListener注解的方法转为ApplicationListener     ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method); } 

值得一提的是，由于注册 EventListenerMethodProcessor 的时候也会默认支持一个名为 ："org.springframework.context.event.internalEventListenerFactory" 的 DefaultEventListenerFactory，这保证至少有一个保底的监听器工厂。

EventListenerFactory 提供两个默认的实现：

• DefaultEventListenerFactory：默认的实现，支持处理所有被 @EventListener 注解的方法，

  会将方法适配成类型为 ApplicationListenerMethodAdapter 的监听器；

• TransactionalEventListenerFactory：支持 Spring 事务机制的监听器的工厂， 用于处理被 @TransactionalEventListener 注解的方法，

  会将方法适配成类型为 ApplicationListenerMethodTransactionalAdapter 的监听器；

3、将方法适配为监听器

当 EventListenerMethodProcessor 作为一个 SmartInitializingSingleton 被调用的时候：

public void afterSingletonsInstantiated() {     ConfigurableListableBeanFactory beanFactory = this.beanFactory;     Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");     // 获取工厂中的全部 Bean     String[] beanNames = beanFactory.getBeanNamesForType(Object.class);     for (String beanName : beanNames) {         if (!ScopedProxyUtils.isScopedTarget(beanName)) {             Class<?> type = null;             try {                 // 如果是代理对象，则获取原始对象的类型                 type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);             }             catch (Throwable ex) {                 // An unresolvable bean type, probably from a lazy bean - let's ignore it.                 if (logger.isDebugEnabled()) {                     logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);                 }             }             if (type != null) {                 // 实现了ScopedObject接口                 if (ScopedObject.class.isAssignableFrom(type)) {                     try {                         // 获取原始的Bean对象                         Class<?> targetClass = AutoProxyUtils.determineTargetClass(                             beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));                         if (targetClass != null) {                             type = targetClass;                         }                     }                     catch (Throwable ex) {                         // An invalid scoped proxy arrangement - let's ignore it.                         if (logger.isDebugEnabled()) {                             logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);                         }                     }                 }                 try {                     // 处理 Bean                     processBean(beanName, type);                 }                 catch (Throwable ex) {                     throw new BeanInitializationException("Failed to process @EventListener " +                                                           "annotation on bean with name '" + beanName + "'", ex);                 }             }         }     } } 

抛开对代理对象的一些检验和处理，我们直接看看 processBean 方法：

private void processBean(final String beanName, final Class<?> targetType) {     if (!this.nonAnnotatedClasses.contains(targetType) &&         // targetType类名不以“java.”开头，且不为Ordered接口         AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&         // 是未被@Component注解的Spring内部类         !isSpringContainerClass(targetType)) {          Map<Method, EventListener> annotatedMethods = null;         try {             // 查找直接或间接带有@EventListener注解的方法             annotatedMethods = MethodIntrospector.selectMethods(targetType,                                                                 (MethodIntrospector.MetadataLookup<EventListener>) method ->                                                                 AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));         }         catch (Throwable ex) {             // An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.             if (logger.isDebugEnabled()) {                 logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);             }         }          // 如果该类没有直接或间接带有@EventListener注解的方法，则记录并在下次查询时跳过         if (CollectionUtils.isEmpty(annotatedMethods)) {             this.nonAnnotatedClasses.add(targetType);             if (logger.isTraceEnabled()) {                 logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());             }         }         else {             // Non-empty set of methods             ConfigurableApplicationContext context = this.applicationContext;             Assert.state(context != null, "No ApplicationContext set");             List<EventListenerFactory> factories = this.eventListenerFactories;             Assert.state(factories != null, "EventListenerFactory List not initialized");             // 遍历注解方法，并遍历监听器工厂             for (Method method : annotatedMethods.keySet()) {                 for (EventListenerFactory factory : factories) {                     // 若工厂支持处理                     if (factory.supportsMethod(method)) {                         // 将方法包装为ApplicationListener                         Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));                         ApplicationListener<?> applicationListener =                             factory.createApplicationListener(beanName, targetType, methodToUse);                         // 如果监听器类型为ApplicationListenerMethodAdapter，则需要传入专门的SpEL表达式解析器EventExpressionEvaluator用于支持@EventListener.condition属性                         if (applicationListener instanceof ApplicationListenerMethodAdapter) {                             ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);                         }                         // 将监听器加入中的                         context.addApplicationListener(applicationListener);                         break;                     }                 }             }             if (logger.isDebugEnabled()) {                 logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +                              beanName + "': " + annotatedMethods);             }         }     } }  @Override public void addApplicationListener(ApplicationListener<?> listener) {     Assert.notNull(listener, "ApplicationListener must not be null");     if (this.applicationEventMulticaster != null) {         this.applicationEventMulticaster.addApplicationListener(listener);     }     this.applicationListeners.add(listener); } 

Spring 在这一步主要趁着 EventListenerMethodProcessor 在 BeanFactory 中初始化的时候干了两件事：

• 检查 BeanFactory 中的所有的 Bean，筛选出其中有成员方法直接或间接带有 @EventListener 注解的 Bean；
• 将此类 Bean 的方法通过 EventListenerFactory 封装为 ApplicationListener 对象；
• 然后将这些转换后得到的 ApplicationListener 注册到上下文中的广播器中；

此外，这里有一个比较有意思的细节，就是由于 @EventListener 注解是支持在 condition 中通过 SpEL 表达式进行一些判断的，因此在这一步，针对默认的监听适配器实现 ApplicationListenerMethodAdapter ，提供了一个 init 方法用于把 SpEL 表达式解析器塞进去：

if (applicationListener instanceof ApplicationListenerMethodAdapter) {     ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator); } 

换而言之，如果我们希望让 @EventListener.condition 支持更多功能，就可以在这个地方动点手脚，比如向 SpEL 表达式上下文注册更多变量。

4、监听器的注册

上一节中提到，在 EventListenerMethodProcessor.processBean 将方法转换为 ApplicationListener 后会将其注入广播器：

public void addApplicationListener(ApplicationListener<?> listener) {     Assert.notNull(listener, "ApplicationListener must not be null");     if (this.applicationEventMulticaster != null) {         // 注册到上下文中的广播器中         this.applicationEventMulticaster.addApplicationListener(listener);     }     this.applicationListeners.add(listener); } 

而 AbstractApplicationContext 会将该方法代理到内部持有的广播器实例的 ApplicationEventMulticaster.addApplicationListener 方法：

public void addApplicationListener(ApplicationListener<?> listener) {    synchronized (this.defaultRetriever) {       // Explicitly remove target for a proxy, if registered already,       // in order to avoid double invocations of the same listener.       Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);       if (singletonTarget instanceof ApplicationListener) {          this.defaultRetriever.applicationListeners.remove(singletonTarget);       }       this.defaultRetriever.applicationListeners.add(listener);       this.retrieverCache.clear();    } } 

该方法最终将监听器添加到广播器持有的 DefaultListenerRetriever 对象实例中，跟已经注册到其中的编程式监听器一起，以待后续使用。

四、监听器工厂

通过上文，我们知道注解式监听器依赖监听器工厂 EventListenerFactory 将 Bean 中的注解方法转为 ApplicationListener 实例。

实际上，我们知道 spring 除了支持 @EventListener 注解外，还提供了 @TransactionalEventListener 注解，用于注册支持事务的注解式监听器，因此 EventListenerFactory 实际上也提供了两类工厂分别用于支持这两种实现：

• DefaultEventListenerFactory：默认的实现，支持处理所有被 @EventListener 注解的方法，

  会将方法适配成类型为 ApplicationListenerMethodAdapter 的监听器；

• TransactionalEventListenerFactory：支持 Spring 事务机制的监听器的工厂， 用于处理被 @TransactionalEventListener 注解的方法，

  会将方法适配成类型为 ApplicationListenerMethodTransactionalAdapter 的监听器；

1、通用监听器工厂

通用监听器工厂的代码及其简单，它的特点如下：

• 支持处理任何方法：supportsMethod 方法固定返回 true；
• 总是最晚被执行：getOrder 默认返回 Ordered.LOWEST_PRECEDENCE；
• 总是将注解方法适配为 ApplicationListenerMethodAdapter 类型的监听器；

public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {      private int order = LOWEST_PRECEDENCE;      public void setOrder(int order) {         this.order = order;     }          @Override     public int getOrder() {         return this.order;     }          @Override     public boolean supportsMethod(Method method) {         return true;     }          @Override     public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {         return new ApplicationListenerMethodAdapter(beanName, type, method);     }  } 

2、事务监听器工厂

事件监听器工厂代码也并不复杂，相比 DefaultEventListenerFactory，它的特点如下：

• 默认比 DefaultEventListenerFactory 更先被调用：getOrder 默认返回 50，比 DefaultEventListenerFactory 返回的 Ordered.LOWEST_PRECEDENCE 值更小；
• 仅支持处理直接或间接被 @TransactionalEventListener 注解的方法；
• 总是将注解方法适配为 ApplicationListenerMethodTransactionalAdapter 类型的监听器；

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {      private int order = 50;      public void setOrder(int order) {         this.order = order;     }      @Override     public int getOrder() {         return this.order;     }       @Override     public boolean supportsMethod(Method method) {         return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);     }      @Override     public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {         return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);     }  } 

总结

当 Spring 容器启动，上下文调用 AbstractApplicationContext.refresh 方法对其进行初始化时，Spring 事件机制的两个核心组件：广播器、监听器也在该过程完成初始化。

• 在 AbstractApplicationContext.initApplicationEventMulticaster 这一步，Spring 为上下文创建并挂载了广播器 ApplicationEventMulticaster 的实例；

• 在 AbstractApplicationContext.registerListeners 这一步，Spring 将容器中所有实现了 ApplicationListener 接口的 Bean 注册到广播器中；

• 而在 AbstractApplicationContext.finishBeanFactoryInitialization 这一步，Spring 会初始化容器中所有非懒加载的 Bean，此时会一并实例化 EventListenerMethodProcessor 这个 Bean 后置处理器：

  1. 这个 Bean 由上下文在准备 BeanFactory 时，调用 loadBeanDefinitions 方法时注册到容器；

  2. 由于 EventListenerMethodProcessor 本身实现了 SmartInitializingSingleton 接口，因此实例化后会触发其回调函数，此时 EventListenerMethodProcessor 会把容器中所有的 Bean 都拿出来解析；

  3. 若 Bean 中存在直接或间接被 @EventListener 注解的方法，则会将其取出，并通过 EventListenerFactory 将其适配为对应的 ApplicationListener 实例，然后再将适配完的监听器注册到容器中；

  4. 由于 Spring 除了 @EventListener 注解还提供了支持事务的@TransactionalEventListener 注解，因此提供了两类监听器工厂：

     DefaultEventListenerFactory：默认的实现，支持处理所有被 @EventListener 注解的方法；

     TransactionalEventListenerFactory：支持 Spring 事务机制的监听器的工厂， 用于处理被 @TransactionalEventListener 注解的方法；

至此，当 AbstractApplicationContext.refresh 执行完毕，即上下文初始化完成后，广播器与所有编程式或注解式监听器皆初始化完毕，并且完成了注册。