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、ApplicationEventMulticasterSimpleApplicationEventMulticaster 是默认实现

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 注解解析流程
    注解处理流程
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值