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 注解解析流程