spring event

fxz大约 28 分钟

spring event

概述

在 bean 的方法上标注 @EventListener 注解。方法应该只有一个参数，即事件对象。
让 bean 实现 ApplicationListener 接口。

两种注册事件监听器的区别：

默认情况下，Spring 通过 ApplicationEventMulticaster 广播发布事件。在这个实例中，所有实现 ApplicationListener 接口的 bean 都会被注册。当发布事件时，系统会遍历所有 ApplicationListener 实例，逐一判断是否匹配，如果匹配则回调 ApplicationListener#onApplicationEvent 方法。换言之，为了确保 ApplicationListener 能够被回调，首先要将其注册到 ApplicationEventMulticaster 中。
使用 ApplicationListener 接口的方式是在实例化单例 bean 之前注册到 ApplicationEventMulticaster 中的。
相较之下，@EventListener 的解析发生在所有单例 bean 注册到 IOC 容器后。因此，如果在创建 IOC 容器过程中发布事件，@EventListener 方式将无法接收到该事件。

广播器的创建

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
       .......
            /**
             *  创建事件广播器
             *  设置 ApplicationContext的 applicationEventMulticaster,要么是用户设置的(注入name：applicationEventMulticaster 的bean)，要么是默认值 SimpleApplicationEventMulticaster
             */
            initApplicationEventMulticaster();

      ......
    }
}

  protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        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 {
            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() 方法完成注册；
在 Bean 初始化后，通过 ApplicationListenerDetector 这个后处理器的 postProcessAfterInitialization 方法将其注册；

由上下文直接注册

编程式监听器在 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 的时候才会一并初始化。

通过后处理器注册

在 AbstractApplicationContext.refresh 方法中，在 prepareBeanFactory 这一步初始化 BeanFactory 时，会默认向工厂注册一个名为 ApplicationListenerDetector Bean 后处理器。

该处理器同时实现了 MergedBeanDefinitionPostProcessor 和 DestructionAwareBeanPostProcessor 和 BeanPostProcessor 三大处理器接口，这分别对应了它处理监听器的三个步骤：

MergedBeanDefinitionPostProcessor：当 Bean 实例化前，对 BeanDefinition 进行进行后处理时，它会记录这些实现了 ApplicationEventListener 接口的 Bean 的名称；
BeanPostProcessor：当 Bean 初始化后，它会根据记录的 BeanName 从容器中找到对应的 Bean 实例，然后将其注册到上下文的广播器中；
DestructionAwareBeanPostProcessor：当 Bean 被销毁时，它会根据记录的 BeanName 将对应的 Bean 从广播器中移除。

注解式监听器的注册

我们可以通过在成员方法上添加 @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 完成初始化的时候；

监听器方法处理器的注册

容器在初始化过程中，通过 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(EventListenerMethodProcessor.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;
}

获取监听器工厂

当 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 的监听器；

将方法适配为监听器

当 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 表达式上下文注册更多变量。

监听器的注册

上一节中提到，在 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 的监听器；

通用监听器工厂

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

支持处理任何方法：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);
    }

}

事务监听器工厂

事件监听器工厂代码也并不复杂，相比 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);
    }

}

事件的推送

AbstractApplicationContext

AbstractApplicationContext:

@Override
public void publishEvent(ApplicationEvent event) {
    publishEvent(event, null);
}

@Override
public void publishEvent(Object event) {
    publishEvent(event, null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");

    ApplicationEvent applicationEvent;
    if (event instanceof ApplicationEvent) {
        applicationEvent = (ApplicationEvent) event;
    } else {
        applicationEvent = new PayloadApplicationEvent<>(this, event);
        if (eventType == null) {
            eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
        }
    }

    if (this.earlyApplicationEvents != null) {
        this.earlyApplicationEvents.add(applicationEvent);
    } else {
        // 发布事件给当前IOC容器注册的 ApplicationListener
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }

    // 把事件发布到父容器中
    if (this.parent != null) {
        if (this.parent instanceof AbstractApplicationContext) {
            ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
        } else {
            this.parent.publishEvent(event);
        }
    }
}

如果事件对象没有继承 ApplicationEvent，则将其包装为 PayloadApplicationEvent；
若早期事件列表为空，说明还在上下文已有可用的广播器，直接通过广播器推送事件，否则就先把事件加入早期事件列表，等到广播器初始化完成后再推送；
如果上下文存在父上下文，则向父上下文也推送事件；
当 registerListeners 还没执行前，任何向上下文推送的事件实际上都不会立刻执行，而是延迟到 registerListeners 这一步才会推送，在这一步后，向上下文推送的事件都会立刻被推送。

SimpleApplicationEventMulticaster

SimpleApplicationEventMulticaster:

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    Executor executor = getTaskExecutor();
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
       if (executor != null) {
          executor.execute(() -> invokeListener(listener, event));
       }
       else {
          invokeListener(listener, event);
       }
    }
}


protected Collection<ApplicationListener<?>> getApplicationListeners(
			ApplicationEvent event, ResolvableType eventType) {

		Object source = event.getSource();
		Class<?> sourceType = (source != null ? source.getClass() : null);
		ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);

		// 从缓存中获取事件对应的监听器检索器，若不存在则新建并加入缓存
		CachedListenerRetriever newRetriever = null;
		CachedListenerRetriever existingRetriever = this.retrieverCache.get(cacheKey);
		if (existingRetriever == null) {
			// Caching a new ListenerRetriever if possible
			if (this.beanClassLoader == null ||
					(ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
							(sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
				newRetriever = new CachedListenerRetriever();
				existingRetriever = this.retrieverCache.putIfAbsent(cacheKey, newRetriever);
				if (existingRetriever != null) {
					newRetriever = null;  // no need to populate it in retrieveApplicationListeners
				}
			}
		}

		// 若存在，则从检索器中获取全部监听器
		if (existingRetriever != null) {
			Collection<ApplicationListener<?>> result = existingRetriever.getApplicationListeners();
			if (result != null) {
				return result;
			}
			// If result is null, the existing retriever is not fully populated yet by another thread.
			// Proceed like caching wasn't possible for this current local attempt.
		}

		// 从检索器中获取所需的监听器
		return retrieveApplicationListeners(eventType, sourceType, newRetriever);
	}

// 检索ApplicationListeners
private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable CachedListenerRetriever retriever) {

		List<ApplicationListener<?>> allListeners = new ArrayList<>();
		Set<ApplicationListener<?>> filteredListeners = (retriever != null ? new LinkedHashSet<>() : null);
		Set<String> filteredListenerBeans = (retriever != null ? new LinkedHashSet<>() : null);

		Set<ApplicationListener<?>> listeners;
		Set<String> listenerBeans;
		synchronized (this.defaultRetriever) {
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}

		// 遍历监听器集合 找到支持的
		for (ApplicationListener<?> listener : listeners) {
			if (supportsEvent(listener, eventType, sourceType)) {
				if (retriever != null) {
					filteredListeners.add(listener);
				}
				allListeners.add(listener);
			}
		}

		if (!listenerBeans.isEmpty()) {
			ConfigurableBeanFactory beanFactory = getBeanFactory();
			for (String listenerBeanName : listenerBeans) {
				try {
					if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
						ApplicationListener<?> listener =
								beanFactory.getBean(listenerBeanName, ApplicationListener.class);
						if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
							if (retriever != null) {
								if (beanFactory.isSingleton(listenerBeanName)) {
									filteredListeners.add(listener);
								}
								else {
									filteredListenerBeans.add(listenerBeanName);
								}
							}
							allListeners.add(listener);
						}
					}
					else {
						// Remove non-matching listeners that originally came from
						// ApplicationListenerDetector, possibly ruled out by additional
						// BeanDefinition metadata (e.g. factory method generics) above.
						Object listener = beanFactory.getSingleton(listenerBeanName);
						if (retriever != null) {
							filteredListeners.remove(listener);
						}
						allListeners.remove(listener);
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					// Singleton listener instance (without backing bean definition) disappeared -
					// probably in the middle of the destruction phase
				}
			}
		}

		AnnotationAwareOrderComparator.sort(allListeners);
		if (retriever != null) {
			if (filteredListenerBeans.isEmpty()) {
				retriever.applicationListeners = new LinkedHashSet<>(allListeners);
				retriever.applicationListenerBeans = filteredListenerBeans;
			}
			else {
				retriever.applicationListeners = filteredListeners;
				retriever.applicationListenerBeans = filteredListenerBeans;
			}
		}
		return allListeners;
	}

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
       try {
          doInvokeListener(listener, event);
       }
       catch (Throwable err) {
          errorHandler.handleError(err);
       }
    }
    else {
       doInvokeListener(listener, event);
    }
}


// 执行监听逻辑
	private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			String msg = ex.getMessage();
			if (msg == null || matchesClassCastMessage(msg, event.getClass()) ||
					(event instanceof PayloadApplicationEvent &&
							matchesClassCastMessage(msg, ((PayloadApplicationEvent) event).getPayload().getClass()))) {
				// Possibly a lambda-defined listener which we could not resolve the generic event type for
				// -> let's suppress the exception.
				Log loggerToUse = this.lazyLogger;
				if (loggerToUse == null) {
					loggerToUse = LogFactory.getLog(getClass());
					this.lazyLogger = loggerToUse;
				}
				if (loggerToUse.isTraceEnabled()) {
					loggerToUse.trace("Non-matching event type for listener: " + listener, ex);
				}
			}
			else {
				throw ex;
			}
		}
	}

ApplicationListenerMethodAdapter:

@Override
	public void onApplicationEvent(ApplicationEvent event) {
		processEvent(event);
	}

public void processEvent(ApplicationEvent event) {
    Object[] args = resolveArguments(event);
    if (shouldHandle(event, args)) {
       Object result = doInvoke(args);
       if (result != null) {
          handleResult(result);
       }
       else {
          logger.trace("No result object given - no result to handle");
       }
    }
}

TransactionalApplicationListenerAdapter:

@Override
public void onApplicationEvent(E event) {
  // 不难理解为什么广播器进行广播的时候，若指定了线程池则事务会失效了，因为具体到监听器适配器调用时，通过 TransactionSynchronizationManager 注册的事务是当前线程池中的工作线程的事务，而调用广播器的主线程的事务与其不是一个事务，因此监听器中事务回滚不会令主线程的事务一并回滚。
    if (TransactionSynchronizationManager.isSynchronizationActive() &&
          TransactionSynchronizationManager.isActualTransactionActive()) {
       TransactionSynchronizationManager.registerSynchronization(
             new TransactionalApplicationListenerSynchronization<>(event, this, this.callbacks));
    }
}

TransactionalApplicationListenerSynchronization:

@Override
public void beforeCommit(boolean readOnly) {
    if (this.listener.getTransactionPhase() == TransactionPhase.BEFORE_COMMIT) {
        processEventWithCallbacks();
    }
}

@Override
public void afterCompletion(int status) {
    TransactionPhase phase = this.listener.getTransactionPhase();
    if (phase == TransactionPhase.AFTER_COMMIT && status == STATUS_COMMITTED) {
        processEventWithCallbacks();
    } else if (phase == TransactionPhase.AFTER_ROLLBACK && status == STATUS_ROLLED_BACK) {
        processEventWithCallbacks();
    } else if (phase == TransactionPhase.AFTER_COMPLETION) {
        processEventWithCallbacks();
    }
}

private void processEventWithCallbacks() {
    // 回调 SynchronizationCallback 前置方法
    this.callbacks.forEach(callback -> callback.preProcessEvent(this.event));
    try {
        /**
         * 回调监听器
         * {@link ApplicationListenerMethodAdapter#processEvent(ApplicationEvent)}
         * */
        this.listener.processEvent(this.event);
    } catch (RuntimeException | Error ex) {
        // 回调 SynchronizationCallback 后置方法
        this.callbacks.forEach(callback -> callback.postProcessEvent(this.event, ex));
        throw ex;
    }
    // 回调 SynchronizationCallback 后置方法
    this.callbacks.forEach(callback -> callback.postProcessEvent(this.event, null));
}

spring event

# spring event

# 概述

# 广播器的创建

# 编程式监听器的注册

# 由上下文直接注册

# 通过后处理器注册

# 注解式监听器的注册

# 监听器方法处理器的注册

# 获取监听器工厂

# 将方法适配为监听器

# 监听器的注册

# 监听器工厂

# 通用监听器工厂

# 事务监听器工厂

# 事件的推送

# AbstractApplicationContext

# SimpleApplicationEventMulticaster

spring event

概述

广播器的创建

编程式监听器的注册

由上下文直接注册

通过后处理器注册

注解式监听器的注册

监听器方法处理器的注册

获取监听器工厂

将方法适配为监听器

监听器的注册

监听器工厂

通用监听器工厂

事务监听器工厂

事件的推送

AbstractApplicationContext

SimpleApplicationEventMulticaster