spring 事件执行流程源码解析

spring事件

观察者模式observer

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

spring事件机制，mq 都是 观察者模式的实现

---

spring event 核心类

1、ApplicationEvent 继承自JDK自带的 EventObject, 抽象事件类，自定事件可以继承该类，例如订单创建事件，订单更新事件，由某个动作出发

2、ApplicationListener 继承自JDK自带的EventListener 事件监听者，观察者模式中的监听者，void onApplicationEvent(E event) 方法会在收到对应类型的事件时触发

• EventListener 注解，效果同ApplicationListener，默认是同步实现，
  • 设置 classes 属性，表示要监听的事件类型
• TransactionalEventListener, 带有事物控制的监听器注解，默认也是同步实现
  • classes 属性，表示要监听的事件类型
  • phase 控制在事务 AFTER_COMMIT提交后、BEFORE_COMMIT提交前、AFTER_ROLLBACK回滚后、AFTER_COMPLETION事务完成后(不管是提交成功还是回滚) 触发监听逻辑
  • fallbackExecution 默认 false ，表示必须在事物下才会触发监听，true ,事务非事务都可以触发监听

3、ApplicationEventPublisher 事件发布器，默认方法publishEvent() 用来发布事件

4、ApplicationEventMulticaster ，SimpleApplicationEventMulticaster 是默认实现

Interface to be implemented by objects that can manage a number of {@link ApplicationListener} objects and publish events to them. 翻译下就是一个spring中的事件广播器，管理listerer 同时又负责广播event给对应的listerer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PTIlXtUg-1649381583382)(C:\Users\69941\Desktop\1.png)]

// Helper class that encapsulates a general set of target listeners.
private final DefaultListenerRetriever defaultRetriever = new DefaultListenerRetriever();
	// 缓存事件和对应的listerer
	final Map<ListenerCacheKey, CachedListenerRetriever> retrieverCache = new ConcurrentHashMap<>(64);

• SimpleApplicationEventMulticaster 在什么时候初始化的？

  EventPublishingRunListener 构造函数中会初始化默认的SimpleApplicationEventMulticaster

  // 类 EventPublishingRunListener 
  public EventPublishingRunListener(SpringApplication application, String[] args) {
          this.application = application;
          this.args = args;
          this.initialMulticaster = new SimpleApplicationEventMulticaster();
          Iterator var3 = application.getListeners().iterator();
  
          while(var3.hasNext()) {
              ApplicationListener<?> listener = (ApplicationListener)var3.next();
              // 添加listenter到initialMulticaster，这里添加的都是一些框架自带的监听器
              this.initialMulticaster.addApplicationListener(listener);
          }
      }
  
  	// 类AbstractApplicationEventMulticaster
  	@Override
  	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();
  		}
  	}
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPNawgu9-1649381583383)(C:\Users\69941\Desktop\3.png)]

  而 EventPublishingRunListener 是通过spi机制加载的，如下图

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xLhsC2sT-1649381583383)(C:\Users\69941\Desktop\2.png)]

• 自定义listener 什么时候添加的？

  //  类ApplicationListenerDetector
  public Object postProcessAfterInitialization(Object bean, String beanName) {
      // 是否是ApplicationListener
  		if (bean instanceof ApplicationListener) {
  			// potentially not detected as a listener by getBeanNamesForType retrieval
  			Boolean flag = this.singletonNames.get(beanName);
  			if (Boolean.TRUE.equals(flag)) {
  				// singleton bean (top-level or inner): register on the fly
                  // 添加
  				this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
  			}
  			else if (Boolean.FALSE.equals(flag)) {
  				if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
  					// inner bean with other scope - can't reliably process events
  					logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
  							"but is not reachable for event multicasting by its containing ApplicationContext " +
  							"because it does not have singleton scope. Only top-level listener beans are allowed " +
  							"to be of non-singleton scope.");
  				}
  				this.singletonNames.remove(beanName);
  			}
  		}
  		return bean;
  	}
  
  
  

• EventListener 注解修饰的什么时候添加的？

  EventListenerMethodProcessor 后置处理器中，

  @Override
  	public void afterSingletonsInstantiated() {
  		ConfigurableListableBeanFactory beanFactory = this.beanFactory;
  		Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
  		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) {
  					if (ScopedObject.class.isAssignableFrom(type)) {
  						try {
  							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 {
                          // 在这里处理
  						processBean(beanName, type);
  					}
  					catch (Throwable ex) {
  						throw new BeanInitializationException("Failed to process @EventListener " +
  								"annotation on bean with name '" + beanName + "'", ex);
  					}
  				}
  			}
  		}
  	}
  	
  private void processBean(final String beanName, final Class<?> targetType) {
  		if (!this.nonAnnotatedClasses.contains(targetType) &&
  				AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
  				!isSpringContainerClass(targetType)) {
  
  			Map<Method, EventListener> annotatedMethods = null;
  			try {
  				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);
  				}
  			}
  
  			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");
                  // 这个工厂有两个实现，DefaultEventListenerFactory和TransactionalEventListenerFactory，看名字就知道，一个是带事务的
  				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)) {
  							Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                              // 这里创建的
  							ApplicationListener<?> applicationListener =
  									factory.createApplicationListener(beanName, targetType, methodToUse);
  							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);
  				}
  			}
  		}
  	}
  

  EventListenerFactory 有两个实现，创建的都是一个监听方法的Adapter

  //TransactionalEventListenerFactory 创建事务监听器
  public class TransactionalEventListenerFactory  implements EventListenerFactory, Ordered {
    
      public boolean supportsMethod(Method method) {
          return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);
      }
  
      public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
          return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);
      }
  }
  // 默认实现
  public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {
  
  	@Override
  	public boolean supportsMethod(Method method) {
  		return true;
  	}
  
  	@Override
  	public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
  		return new ApplicationListenerMethodAdapter(beanName, type, method);
  	}
  
  }
  

  ApplicationListenerMethodAdapter 的processEvent方法就是回调监听器的方法

  public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
  
  	private static final boolean reactiveStreamsPresent = ClassUtils.isPresent(
  			"org.reactivestreams.Publisher", ApplicationListenerMethodAdapter.class.getClassLoader());
  
  
  	protected final Log logger = LogFactory.getLog(getClass());
  
  	private final String beanName;
  
  	private final Method method;
  
  	private final Method targetMethod;
  
  	private final AnnotatedElementKey methodKey;
  
  	private final List<ResolvableType> declaredEventTypes;
  
  	@Nullable
  	private ApplicationContext applicationContext;
  
  
  	@Override
  	public void onApplicationEvent(ApplicationEvent event) {
  		processEvent(event);
  	}
  
      // 是否是支持的类型
  	@Override
  	public boolean supportsEventType(ResolvableType eventType) {
  		for (ResolvableType declaredEventType : this.declaredEventTypes) {
  			if (declaredEventType.isAssignableFrom(eventType)) {
  				return true;
  			}
  			if (PayloadApplicationEvent.class.isAssignableFrom(eventType.toClass())) {
  				ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
  				if (declaredEventType.isAssignableFrom(payloadType)) {
  					return true;
  				}
  			}
  		}
  		return eventType.hasUnresolvableGenerics();
  	}
  
  	@Override
  	public boolean supportsSourceType(@Nullable Class<?> sourceType) {
  		return true;
  	}
  
  	@Override
  	public int getOrder() {
  		return this.order;
  	}
  
  
  	/**
  	 * Process the specified {@link ApplicationEvent}, checking if the condition
  	 * matches and handling a non-null result, if any.
  	 */
  	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");
  			}
  		}
  	}
  
  
  	@Nullable
  	protected Object[] resolveArguments(ApplicationEvent event) {
  		ResolvableType declaredEventType = getResolvableType(event);
  		if (declaredEventType == null) {
  			return null;
  		}
  		if (this.method.getParameterCount() == 0) {
  			return new Object[0];
  		}
  		Class<?> declaredEventClass = declaredEventType.toClass();
  		if (!ApplicationEvent.class.isAssignableFrom(declaredEventClass) &&
  				event instanceof PayloadApplicationEvent) {
  			Object payload = ((PayloadApplicationEvent<?>) event).getPayload();
  			if (declaredEventClass.isInstance(payload)) {
  				return new Object[] {payload};
  			}
  		}
  		return new Object[] {event};
  	}
  
  	protected void handleResult(Object result) {
  		if (reactiveStreamsPresent && new ReactiveResultHandler().subscribeToPublisher(result)) {
  			if (logger.isTraceEnabled()) {
  				logger.trace("Adapted to reactive result: " + result);
  			}
  		}
  		else if (result instanceof CompletionStage) {
  			((CompletionStage<?>) result).whenComplete((event, ex) -> {
  				if (ex != null) {
  					handleAsyncError(ex);
  				}
  				else if (event != null) {
  					publishEvent(event);
  				}
  			});
  		}
  		else if (result instanceof ListenableFuture) {
  			((ListenableFuture<?>) result).addCallback(this::publishEvents, this::handleAsyncError);
  		}
  		else {
  			publishEvents(result);
  		}
  	}
  
  	private void publishEvents(Object result) {
  		if (result.getClass().isArray()) {
  			Object[] events = ObjectUtils.toObjectArray(result);
  			for (Object event : events) {
  				publishEvent(event);
  			}
  		}
  		else if (result instanceof Collection<?>) {
  			Collection<?> events = (Collection<?>) result;
  			for (Object event : events) {
  				publishEvent(event);
  			}
  		}
  		else {
  			publishEvent(result);
  		}
  	}
  
  	private void publishEvent(@Nullable Object event) {
  		if (event != null) {
  			Assert.notNull(this.applicationContext, "ApplicationContext must not be null");
  			this.applicationContext.publishEvent(event);
  		}
  	}
  
  	protected void handleAsyncError(Throwable t) {
  		logger.error("Unexpected error occurred in asynchronous listener", t);
  	}
  
  	private boolean shouldHandle(ApplicationEvent event, @Nullable Object[] args) {
  		if (args == null) {
  			return false;
  		}
  		String condition = getCondition();
  		if (StringUtils.hasText(condition)) {
  			Assert.notNull(this.evaluator, "EventExpressionEvaluator must not be null");
  			return this.evaluator.condition(
  					condition, event, this.targetMethod, this.methodKey, args, this.applicationContext);
  		}
  		return true;
  	}
  
  	/**
  	 * Invoke the event listener method with the given argument values.
  	 */
  	@Nullable
  	protected Object doInvoke(Object... args) {
  		Object bean = getTargetBean();
  		// Detect package-protected NullBean instance through equals(null) check
  		if (bean.equals(null)) {
  			return null;
  		}
  
  		ReflectionUtils.makeAccessible(this.method);
  		try {
              // 反射调用注解修饰的方法
  			return this.method.invoke(bean, args);
  		}
  		catch (IllegalArgumentException ex) {
  		///....
  		}
  	}
  
  	
  }
  
  

• 不通类型的事件和监听器列表怎么关联的？

  ApplicationEventPublisher.publishEvent(ApplicationEvent event) -->SimpleApplicationEventMulticaster.multicastEvent(applicationEvent, eventType) -->SimpleApplicationEventMulticaster.getApplicationListeners -->SimpleApplicationEventMulticaster.retrieveApplicationListeners(eventType, sourceType, newRetriever)

  //缓存事件和对应的监听器
  final Map<ListenerCacheKey, CachedListenerRetriever> retrieverCache = new ConcurrentHashMap<>(64);
  

  public interface ApplicationEventPublisher {
  	 // 发送事件
  	default void publishEvent(ApplicationEvent event) {
          //父类 AbstractApplicationContext 实现
  		publishEvent((Object) event);
  	}
  
  }
  
  public abstract class AbstractApplicationContext extends DefaultResourceLoader
  		implements ConfigurableApplicationContext {
  			    
      @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");
  
  		// Decorate event as an ApplicationEvent if necessary
  		ApplicationEvent applicationEvent;
  		if (event instanceof ApplicationEvent) {
  			applicationEvent = (ApplicationEvent) event;
  		}
  		else {
  			applicationEvent = new PayloadApplicationEvent<>(this, event);
  			if (eventType == null) {
  				eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
  			}
  		}
  
  		// Multicast right now if possible - or lazily once the multicaster is initialized
  		if (this.earlyApplicationEvents != null) {
  			this.earlyApplicationEvents.add(applicationEvent);
  		}
  		else {
  		// 获取事件广播器，广播事件
  			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
  		}
  		// Publish event via parent context as well...
  		if (this.parent != null) {
  			if (this.parent instanceof AbstractApplicationContext) {
  				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
  			}
  			else {
  				this.parent.publishEvent(event);
  			}
  		}
  	}
  }
  public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
  	@Override
  	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
  		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  		Executor executor = getTaskExecutor();
  		// getApplicationListeners(event, type) 获取对应类型的监听器
  		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
  			if (executor != null) {
  				// executor 不为空，是异步处理
  				// 这里的executor 默认是空的，我们可以自定义 SimpleApplicationEventMulticaster，然后设置executor就可以异步执行，
  				// 如果使用 @EnableAsync+@Async 也可以异步，但是不是走这里处理的
  				executor.execute(() -> invokeListener(listener, event));
  			}
  			else {
  				// 同步处理	
  				invokeListener(listener, event);
  			}
  		}
  	}
  	// 回调执行监听器的方法
  	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) {
  			//....
  		}
  	}
  
  	
  	protected Collection<ApplicationListener<?>> getApplicationListeners(
  			ApplicationEvent event, ResolvableType eventType) {
  
  		Object source = event.getSource();
  		Class<?> sourceType = (source != null ? source.getClass() : null);
  		// key
  		ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);
  
  		// Potential new retriever to populate
  		CachedListenerRetriever newRetriever = null;
  
  		// Quick check for existing entry on ConcurrentHashMap
  		// 根据key 去缓存中取
  		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();
  				// 初始化一个空的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.
  		}
  		// 为空走这里处理，可以理解为给CachedListenerRetriever 里面的监听器列表赋值
  		return retrieveApplicationListeners(eventType, sourceType, newRetriever);
  	}
  	// retrieveApplicationListeners 检索监听器
  	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);
  		}
  
  		// Add programmatically registered listeners, including ones coming
  		// from ApplicationListenerDetector (singleton beans and inner beans).
  		for (ApplicationListener<?> listener : listeners) {
  				
  			if (supportsEvent(listener, eventType, sourceType)) {
  			 	// 判断是支持的类型，添加
  				if (retriever != null) {
  					filteredListeners.add(listener);
  				}
  				allListeners.add(listener);
  			}
  		}
  
  		// Add listeners by bean name, potentially overlapping with programmatically
  		// registered listeners above - but here potentially with additional metadata.
  		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;
  	}
  ｝
  

@EventListener 处理流程

通过上面的源码可以看到，@EventListener修饰的方法，会被EventListenerMethodProcessor 后置处理器，处理 创建一个 ApplicationListenerMethodAdapter,并添加到 事件广播器SimpleApplicationEventMulticaster中，下面来看看事件发布之后的处理流程

• 发布事件ApplicationEventPublisher.publishEvent()发布事件

  @Override
  	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);
  			}
  		}
  	}
  
  

• ApplicationEventMulticaster.multicastEvent() 广播事件

  • 这里会通过ApplicationEventMulticaster.getApplicationListeners获取事件对应的监听器列表,这里会有把对应的事件和监听器列表缓存起来,源码可以看上面

  • 循环执行所有的监听器

    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
    			if (executor != null) {
    				executor.execute(() -> invokeListener(listener, event));
    			}
    			else {
    				invokeListener(listener, event);
    			}
    		}
    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 {
                // onApplicationEvent
    			listener.onApplicationEvent(event);
    		}
    }
    
    

  • ApplicationListenerMethodAdapter适配器执行processEvent方法

    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");
    			}
    		}
    	}
    
    

  • @TransactionalEventListener 注解的监听器创建的适配器是TransactionalApplicationListenerMethodAdapter,处理有事务控制的事件

    public class TransactionalApplicationListenerMethodAdapter extends ApplicationListenerMethodAdapter
    		implements TransactionalApplicationListener<ApplicationEvent> {
    
    	private final TransactionalEventListener annotation;
    
    	private final TransactionPhase transactionPhase;
    
    
    	@Override
    	public void onApplicationEvent(ApplicationEvent event) {
    	
    		if (TransactionSynchronizationManager.isSynchronizationActive() &&
    				TransactionSynchronizationManager.isActualTransactionActive()) {
    				// 判断有事务存在，注册一个事务同步器
    			TransactionSynchronizationManager.registerSynchronization(
    					// 创建事务同步器
    					new TransactionalApplicationListenerSynchronization<>(event, this, this.callbacks));
    		}
    		else if (this.annotation.fallbackExecution()) {
    			if (this.annotation.phase() == TransactionPhase.AFTER_ROLLBACK && logger.isWarnEnabled()) {
    				logger.warn("Processing " + event + " as a fallback execution on AFTER_ROLLBACK phase");
    			}
    			// fallbackExecution=true,也会直接调用监听器处理，这里就和EventListener一样的处理逻辑
    			processEvent(event);
    		}
    		else {
    			// No transactional event execution at all
    			if (logger.isDebugEnabled()) {
    				logger.debug("No transaction is active - skipping " + event);
    			}
    		}
    	}
    
    }
    
    
    

    事务同步器

    class TransactionalApplicationListenerSynchronization<E extends ApplicationEvent>
    		implements TransactionSynchronization {
    
    	private final E event;
    
    	private final TransactionalApplicationListener<E> listener;
    
    	private final List<TransactionalApplicationListener.SynchronizationCallback> callbacks;
    
    	// 事务提交之前
    	@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() {
    		this.callbacks.forEach(callback -> callback.preProcessEvent(this.event));
    		try {
    			// 还是调用监听器的processEvent
    			this.listener.processEvent(this.event);
    		}
    		catch (RuntimeException | Error ex) {
    			this.callbacks.forEach(callback -> callback.postProcessEvent(this.event, ex));
    			throw ex;
    		}
    		this.callbacks.forEach(callback -> callback.postProcessEvent(this.event, null));
    	}
    
    }
    
    
    

---

流程图

• 事件发布监听流程
  
• @eventListener 注解解析流程