spring事件驱动分析

蔚落 2022-09-10 05:26 201阅读 0赞

### 文章目录 ###

*   *  前言
     *  spring事件编程-实践
     *  观察者模式和发布-订阅模式
     *  spring事件驱动源码分析
     *   *  publishEvent()源码跟踪：
         *  @EventListener注解实现源码分析
     *  结语

## 前言 ##

众所周知，在领域驱动设计中聚合根的设计有一个很重要的原则：

**每个事务应该只更新一个聚合根。**

然而，在我们的实际业务中，经常会出现涉及到多个聚合根同时更新的场景。这无疑对于系统设计提出了不小的挑战，设计一个粒度适中，又能符合业务要求的聚合根并不是一件容易的事情。领域事件为我们提供了一种非常简单的解决方案：在聚合根完成更新后产生一个新的事件并广播出去，由其他订阅该事件的订阅者完成其他聚合根的更新，这样就解除了聚合根之间的耦合。

如果是多个域之间的事件交互，可以考虑使用kafka等消息中间件实现，今天本文介绍的是spring中的事件编程，适合用在单个域中包含多个聚合根的场景。

在java中，本身就已经自带了对事件编程的支持(java.util.EventObject)，早期的GUI编程中使用事件编程会比较多。而spring又对java的事件做了进一步扩充，本文会通过简单梳理事件驱动编程在spring boot中的实践，学习其思想和技巧，为我们更好的设计代码架构提供参考。

## spring事件编程-实践 ##

我们先看一下spring事件编程的简单实践。

我们用spring的事件机制，模拟实现一个简单的业务场景：

**在用户完成下单动作以后，我们需要给到用户邮件通知，这里涉及邮件和订单两个模块，我们在下单动作完成后，发布事件，再由邮件模块发送邮件给用户。**

**入口函数** ：

@Slf4j
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class Main { 
    
        @Autowired
        private OrderService orderService;
    
        @Test
        public void placeOrder(){ 
            Order order = new Order();
            order.setUserName("lisi");
            order.setEmail("lisi@qq.com");
            orderService.placeOrder(order);
            log.info("下单完成");
        }
    }

**订单实体**：

@Getter
    @Setter
    @ToString
    public class Order { 
        private String userName;
        private String email;
    }

**订单service**：

我们在完成订单保存后，并没有显式调用邮件发送，而是发布了一个“订单事件”，后面交给其他感兴趣的订阅模块去做相应处理，实现了很好的解耦。发布事件借助spring的ApplicationEventPublisher完成，后面会再细说它的具体实现。

@Slf4j
    @Service
    public class OrderService { 
    
        @Autowired
        private ApplicationEventPublisher publisher;
    
        public void placeOrder(Order order) { 
            this.saveOrder(order);
            log.info("发布下单事件成功:[{}]", order);
            publisher.publishEvent(order);
        }
    
        private void saveOrder(Order order) { 
            log.info("保存订单");
        }
    }

**邮件监听器**:

我们只需要在业务方法上加@EventListener注解即可实现监听。

注意：监听器需要是被spring管理的bean，@Service或者@Component等都可以

@Slf4j
    @Service
    public class EmailListener { 
        private void sendEmail(Order order){ 
            //发邮件
            log.info("发送邮件");
            //throw new RuntimeException("模拟发送邮件异常");
        }
    
        @EventListener
        public void placeOrderNotice(Order order){ 
            log.info("邮件监听器收到通知[{}]", order);
            this.sendEmail(order);
        }
    }

**运行结果**：

可以看到下单后，监听器拿到了订单信息，并成功发送了邮件。

![初次运行结果][d9cc6bc2237c451a9f2257d4e8d7d997.png]

需要注意的是，这里的监听器是同步执行的，如果发送邮件出现异常，那么会导致主线程后面逻辑也走不下去，如果包含事务，那么事务也会回滚。  
例如，我们模拟在邮件发送中出现异常，再看结果：

private void sendEmail(Order order){ 
            //发邮件
            log.info("发送邮件");
            throw new RuntimeException("模拟发送邮件异常");
    }

![异常运行结果][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_20_color_FFFFFF_t_70_g_se_x_16]  
可以看到，发送邮件抛出异常，导致日志\[下单完成\]，也没有正常执行，此处若有事务也会回滚；  
要想订阅者的逻辑不影响主线程，我们可以使用异步执行的方式，在springBoot入口类添加 **@EnableAsync**注解，并在监听器中添加注解 **@Async** 即可。

@Slf4j
    @EnableAsync
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AsyncMain { 
    			......
    }
    
    @Async
    @EventListener
    public void placeOrderNotice1(Order order){ 
    log.info("异步邮件监听器[1]收到通知[{}]", order);
        this.sendEmail1(order);
    }

如不指定Executor，则会使用默认的applicationTaskExecutor，我们也可以自定义Executor:

@Bean
      public ThreadPoolTaskExecutor myExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(5);
            executor.setMaxPoolSize(50);
            return executor;
      }

如果有多个订阅者，还可以通过 **@Order** 注解指定收到通知的顺序，数字越小优先级越高，本例我们指定两个订阅者。

@Async
        @EventListener
        @org.springframework.core.annotation.Order(1)
        public void placeOrderNotice1(Order order){ 
            log.info("异步邮件监听器[1]收到通知[{}]", order);
            this.sendEmail1(order);
        }
    		private void sendEmail1(Order order){ 
            log.info("发送邮件1");
            throw new RuntimeException("异步发送邮件[1]异常");
        }
    
        @Async
        @EventListener
        @org.springframework.core.annotation.Order(2)
        public void placeOrderNotice2(Order order){ 
            log.info("异步邮件监听器[2]收到通知[{}]", order);
            this.sendEmail2(order);
        }
    		private void sendEmail2(Order order){ 
            log.info("发送邮件2");
        }

运行结果：  
![异步执行结果][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
可以看到这里使用了自定义的myExecutor去异步化执行监听器中的逻辑，而且异步化之后，监听器\[1\]执行出现异常，没有影响主线程和监听器\[2\]。

## 观察者模式和发布-订阅模式 ##

在spring中的事件编程，其实就是我们常说的设计模式中的观察者模式的实现，也看到有人说观察者模式=发布订阅模式，其实这两者是有差别的。

在观察者模式中，观察者需要直接订阅目标事件；在目标发出内容改变的事件后，直接接收事件并作出响应，如下：

╭─────────────╮  Fire Event  ╭──────────────╮
     │             │─────────────>│              │
     │   Subject   │              │   Observer   │
     │             │<─────────────│              │
     ╰─────────────╯  Subscribe   ╰──────────────╯

在发布订阅模式中，发布者和订阅者之间多了一个发布通道；一方面从发布者接收事件，另一方面向订阅者发布事件；订阅者需要从事件通道订阅事件,以此避免发布者和订阅者之间产生依赖关系,如下：

╭─────────────╮                 ╭───────────────╮   Fire Event   ╭──────────────╮
     │             │  Publish Event  │               │───────────────>│              │
     │  Publisher  │────────────────>│ Event Channel │                │  Subscriber  │
     │             │                 │               │<───────────────│              │
     ╰─────────────╯                 ╰───────────────╯    Subscribe   ╰──────────────╯

发布-订阅可以认为是观察者模式的一种实现。在spring中的事件编程，都是观察者模式的实现，没有涉及消息中间件，如果业务足够复杂，可以考虑引入第三方消息中间件来实现领域事件。

## spring事件驱动源码分析 ##

spring这么多年经久不衰，它的源码可谓是经典中的经典，里面的抽象和设计都是值得我们学习和研究的，下面我们就一起看一下spring是如何实现事件驱动的。

**Spring事件机制涉及的重要的类主要有以下四个**：

*  ApplicationEvent：事件，该抽象类是所有Spring事件的父类，继承自java的EventObject。
 *  ApplicationListener：事件监听器接口，继承自java的EventListener。
 *  ApplicationEventMulticaster：事件管理者，管理监听器和发布事件，ApplicationContext通过委托ApplicationEventMulticaster来 发布事件
 *  ApplicationEventPublisher：事件发布者，该接口封装了事件有关的公共方法，作为ApplicationContext的超级接口，也是委托 ApplicationEventMulticaster完成事件发布。

然后我们开始看具体的源码。我们从最简单的发布事件开始跟踪，可以看到，publishEvent方法的逻辑最终是在AbstractApplicationContext.java中，而AbstractApplicationContext是ApplicationEventPublisher的实现类：

![AbstractApplicationContext][]

### publishEvent()源码跟踪： ###

protected void publishEvent(Object event, @Nullable ResolvableType eventType) { 
            Assert.notNull(event, "Event must not be null");
            Object 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 { 
    						//注意这里，委托给ApplicationEventMulticaster发布器去处理了
                this.getApplicationEventMulticaster().multicastEvent((ApplicationEvent)applicationEvent, eventType);
            }
    
            if (this.parent != null) { 
                if (this.parent instanceof AbstractApplicationContext) { 
                    ((AbstractApplicationContext)this.parent).publishEvent(event, eventType);
                } else { 
                    this.parent.publishEvent(event);
                }
            }
    
        }

我们再看发布器的初始化代码initApplicationEventMulticaster:

protected void initApplicationEventMulticaster() { 
            ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
            if (beanFactory.containsLocalBean("applicationEventMulticaster")) { 
                this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
                if (this.logger.isTraceEnabled()) { 
                    this.logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
                }
            } else { 
    						//注意这里，用实现类SimpleApplicationEventMulticaster去处理发布事件
                this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
                beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
                if (this.logger.isTraceEnabled()) { 
                    this.logger.trace("No 'applicationEventMulticaster' bean, using [" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
                }
            }
    
        }

再看SimpleApplicationEventMulticaster中的发布事件方法multicastEvent():

public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) { 
            ResolvableType type = eventType != null ? eventType : this.resolveDefaultEventType(event);
            Executor executor = this.getTaskExecutor();
            Iterator var5 = this.getApplicationListeners(event, type).iterator();
    
            while(var5.hasNext()) { 
                ApplicationListener<?> listener = (ApplicationListener)var5.next();
                if (executor != null) { 
    								//异步的执行方法
                    executor.execute(() -> { 
                        this.invokeListener(listener, event);
                    });
                } else { 
    								//同步的执行方法
                    this.invokeListener(listener, event);
                }
            }
    
        }

再看invokeListener：

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) { 
            ErrorHandler errorHandler = this.getErrorHandler();
            if (errorHandler != null) { 
                try { 
    								//看这个
                    this.doInvokeListener(listener, event);
                } catch (Throwable var5) { 
                    errorHandler.handleError(var5);
                }
            } else { 
    						//看这个
                this.doInvokeListener(listener, event);
            }
    
        }
    
        private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) { 
            try { 
    						//实际上执行了监听器的onApplicationEvent方法
                listener.onApplicationEvent(event);
            } catch (ClassCastException var6) { 
                String msg = var6.getMessage();
                if (msg != null && !this.matchesClassCastMessage(msg, event.getClass())) { 
                    throw var6;
                }
    
                Log logger = LogFactory.getLog(this.getClass());
                if (logger.isTraceEnabled()) { 
                    logger.trace("Non-matching event type for listener: " + listener, var6);
                }
            }
    
        }

总结一下上面的流程：ApplicationEventPublisher发布事件是委托给ApplicationEventMulticaster去执行的，ApplicationEventMulticaster的实现类SimpleApplicationEventMulticaster最终会调用ApplicationListener的onApplicationEvent方法。

### @EventListener注解实现源码分析 ###

那么问题来了，我们的监听器实际上只用了一个@EventListener注解，并没有onApplicationEvent方法，spring又是如何来识别的呢？

众所周知，spring容器启动时，会有一个refresh的动作(org.springframework.boot.SpringApplication\#run())，如下：

public ConfigurableApplicationContext run(String... args) { 
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
            ConfigurableApplicationContext context = null;
            Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
            this.configureHeadlessProperty();
            SpringApplicationRunListeners listeners = this.getRunListeners(args);
            listeners.starting();
    
            Collection exceptionReporters;
            try { 
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
                this.configureIgnoreBeanInfo(environment);
                Banner printedBanner = this.printBanner(environment);
                context = this.createApplicationContext();
                exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ ConfigurableApplicationContext.class}, context);
                //准备变量
    						this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
                //注意这里：刷新容器
    						this.refreshContext(context);
                this.afterRefresh(context, applicationArguments);
                stopWatch.stop();
                if (this.logStartupInfo) { 
                    (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
                }
    
                listeners.started(context);
                this.callRunners(context, applicationArguments);
            } catch (Throwable var10) { 
                this.handleRunFailure(context, var10, exceptionReporters, listeners);
                throw new IllegalStateException(var10);
            }
    
            try { 
                listeners.running(context);
                return context;
            } catch (Throwable var9) { 
                this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
                throw new IllegalStateException(var9);
            }
        }

再看refreshContext()里面的内容：

private void refreshContext(ConfigurableApplicationContext context) { 
            //再看下面
    				this.refresh(context);
            if (this.registerShutdownHook) { 
                try { 
                    context.registerShutdownHook();
                } catch (AccessControlException var3) { 
                }
     }
    protected void refresh(ApplicationContext applicationContext) { 
            Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
    				//调用了applicationContext.refresh()
            ((AbstractApplicationContext)applicationContext).refresh();
    }

里面实际调用了applicationContext的refresh，applicationContext就是我们前面调用publishEvent的类，也是ApplicationEventPublisher的实现类，我们来看看AbstractApplicationContext的refresh做了什么：

public void refresh() throws BeansException, IllegalStateException { 
            synchronized(this.startupShutdownMonitor) { 
                this.prepareRefresh();
                ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
                this.prepareBeanFactory(beanFactory);
    
                try { 
                    this.postProcessBeanFactory(beanFactory);
                    this.invokeBeanFactoryPostProcessors(beanFactory);
                    this.registerBeanPostProcessors(beanFactory);
                    this.initMessageSource();
    								//初始化事件发布器
                    this.initApplicationEventMulticaster();
                    this.onRefresh();
    								//注册事件监听器
                    this.registerListeners();
    								//我们要关注的和注解有关的地方
                    this.finishBeanFactoryInitialization(beanFactory);
                    this.finishRefresh();
                } catch (BeansException var9) { 
                    if (this.logger.isWarnEnabled()) { 
                        this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                    }
    
                    this.destroyBeans();
                    this.cancelRefresh(var9);
                    throw var9;
                } finally { 
                    this.resetCommonCaches();
                }
    
            }
        }

我们来看finishBeanFactoryInitialization()方法：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
            if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) { 
                beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
            }
    
            if (!beanFactory.hasEmbeddedValueResolver()) { 
                beanFactory.addEmbeddedValueResolver((strVal) -> { 
                    return this.getEnvironment().resolvePlaceholders(strVal);
                });
            }
    
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            String[] var3 = weaverAwareNames;
            int var4 = weaverAwareNames.length;
    
            for(int var5 = 0; var5 < var4; ++var5) { 
                String weaverAwareName = var3[var5];
                this.getBean(weaverAwareName);
            }
    
            beanFactory.setTempClassLoader((ClassLoader)null);
            beanFactory.freezeConfiguration();
    				//注意这里
            beanFactory.preInstantiateSingletons();
        }

继续跟进preInstantiateSingletons():

public void preInstantiateSingletons() throws BeansException { 
            if (this.logger.isTraceEnabled()) { 
                this.logger.trace("Pre-instantiating singletons in " + this);
            }
    
            List<String> beanNames = new ArrayList(this.beanDefinitionNames);
            Iterator var2 = beanNames.iterator();
    
            while(true) { 
                String beanName;
                Object bean;
                do { 
                    while(true) { 
                        RootBeanDefinition bd;
                        do { 
                            do { 
                                do { 
                                    if (!var2.hasNext()) { 
                                        var2 = beanNames.iterator();
    
                                        while(var2.hasNext()) { 
                                            beanName = (String)var2.next();
                                            Object singletonInstance = this.getSingleton(beanName);
                                            if (singletonInstance instanceof SmartInitializingSingleton) { 
                                                SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                                if (System.getSecurityManager() != null) { 
                                                    AccessController.doPrivileged(() -> { 
    																										//注意这里
                                                        smartSingleton.afterSingletonsInstantiated();
                                                        return null;
                                                    }, this.getAccessControlContext());
                                                } else { 
    																								//注意这里
                                                    smartSingleton.afterSingletonsInstantiated();
                                                }
                                            }
                                        }
    
                                        return;
                                    }
    
                                    beanName = (String)var2.next();
                                    bd = this.getMergedLocalBeanDefinition(beanName);
                                } while(bd.isAbstract());
                            } while(!bd.isSingleton());
                        } while(bd.isLazyInit());
    
                        if (this.isFactoryBean(beanName)) { 
                            bean = this.getBean("&" + beanName);
                            break;
                        }
    
                        this.getBean(beanName);
                    }
                } while(!(bean instanceof FactoryBean));
    
                FactoryBean<?> factory = (FactoryBean)bean;
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { 
                    SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                    ((SmartFactoryBean)factory).getClass();
                    isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
                } else { 
                    isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
                }
    
                if (isEagerInit) { 
                    this.getBean(beanName);
                }
            }
        }

再来看SmartInitializingSingleton.afterSingletonsInstantiated()，SmartInitializingSingleton这个接口有几个实现类，明显EventListenerMethodProcessor就是我们所关注的：  
![SmartInitializingSingleton][]

再看EventListenerMethodProcessor.afterSingletonsInstantiated（）：

public void afterSingletonsInstantiated() { 
            ConfigurableListableBeanFactory beanFactory = this.beanFactory;
            Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
            String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
            String[] var3 = beanNames;
            int var4 = beanNames.length;
    
            for(int var5 = 0; var5 < var4; ++var5) { 
                String beanName = var3[var5];
                if (!ScopedProxyUtils.isScopedTarget(beanName)) { 
                    Class type = null;
    
                    try { 
                        type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
                    } catch (Throwable var10) { 
                        if (this.logger.isDebugEnabled()) { 
                            this.logger.debug("Could not resolve target class for bean with name '" + beanName + "'", var10);
                        }
                    }
    
                    if (type != null) { 
                        if (ScopedObject.class.isAssignableFrom(type)) { 
                            try { 
                                Class<?> targetClass = AutoProxyUtils.determineTargetClass(beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
                                if (targetClass != null) { 
                                    type = targetClass;
                                }
                            } catch (Throwable var11) { 
                                if (this.logger.isDebugEnabled()) { 
                                    this.logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", var11);
                                }
                            }
                        }
    
                        try { 
    												//我们的关注点
                            this.processBean(beanName, type);
                        } catch (Throwable var9) { 
                            throw new BeanInitializationException("Failed to process @EventListener annotation on bean with name '" + beanName + "'", var9);
                        }
                    }
                }
            }
    
        }

再看processBean():

private void processBean(String beanName, Class<?> targetType) { 
    				//处理@EventListener注解的方法
            if (!this.nonAnnotatedClasses.contains(targetType) && AnnotationUtils.isCandidateClass(targetType, EventListener.class) && !isSpringContainerClass(targetType)) { 
                Map annotatedMethods = null;
    
                try { 
                    annotatedMethods = MethodIntrospector.selectMethods(targetType, (methodx) -> { 
                        return (EventListener)AnnotatedElementUtils.findMergedAnnotation(methodx, EventListener.class);
                    });
                } catch (Throwable var12) { 
                    if (this.logger.isDebugEnabled()) { 
                        this.logger.debug("Could not resolve methods for bean with name '" + beanName + "'", var12);
                    }
                }
    
                if (CollectionUtils.isEmpty(annotatedMethods)) { 
                    this.nonAnnotatedClasses.add(targetType);
                    if (this.logger.isTraceEnabled()) { 
                        this.logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
                    }
                } else { 
                    ConfigurableApplicationContext context = this.applicationContext;
                    Assert.state(context != null, "No ApplicationContext set");
                    List<EventListenerFactory> factories = this.eventListenerFactories;
                    Assert.state(factories != null, "EventListenerFactory List not initialized");
                    Iterator var6 = annotatedMethods.keySet().iterator();
    
                    while(true) { 
                        while(var6.hasNext()) { 
                            Method method = (Method)var6.next();
                            Iterator var8 = factories.iterator();
    
                            while(var8.hasNext()) { 
                                EventListenerFactory factory = (EventListenerFactory)var8.next();
                                if (factory.supportsMethod(method)) { 
                                    Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
    																//EventListenerFactory这里根据我们@EventListener注解的方法构建出了ApplicationListener
                                    ApplicationListener<?> applicationListener = factory.createApplicationListener(beanName, targetType, methodToUse);
                                    if (applicationListener instanceof ApplicationListenerMethodAdapter) { 
                                        ((ApplicationListenerMethodAdapter)applicationListener).init(context, this.evaluator);
                                    }
    
                                    context.addApplicationListener(applicationListener);
                                    break;
                                }
                            }
                        }
    
                        if (this.logger.isDebugEnabled()) { 
                            this.logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" + beanName + "': " + annotatedMethods);
                        }
                        break;
                    }
                }
            }
    
        }

我们再来看EventListenerFactory.createApplicationListener():

public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) { 
            //这里其实是使用了适配器模式，构建了一个适配器返回
    				return new ApplicationListenerMethodAdapter(beanName, type, method);
        }

可以看到ApplicationListenerMethodAdapter适配器继承自ApplicationListener  
![请添加图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_19_color_FFFFFF_t_70_g_se_x_16]

到这里，其实就已经很清晰了，在spring容器启动时applicationContext会调用refresh方法，然后一路跟踪到注解@EventListenser的处理类EventListenerMethodProcessor中的afterSingletonsInstantiated()方法，再到EventListenerMethodProcessor.processBean()中，找到了对针对注解@EventListenser的处理逻辑：  
根据传入的beanName通过EventListenerFactory构建出一个ApplicationListenerMethodAdapter适配器，该适配器也是ApplicationListenser的实现，也就把我们用@EventListenser注解的方法适配成了ApplicationListenser的实现。

最后我们再看看，这个适配器是如何实现适配的。我们知道，发布事件时会调用onApplicationEvent方法，我们来看看ApplicationListenerMethodAdapter中的onApplicationEvent实现:

public void onApplicationEvent(ApplicationEvent event) { 
    				//看下面的具体方法
            this.processEvent(event);
    }
    
    public void processEvent(ApplicationEvent event) { 
            Object[] args = this.resolveArguments(event);
            if (this.shouldHandle(event, args)) { 
    						//这里通过反射来执行被@EventListenser注解的方法
                Object result = this.doInvoke(args);
                if (result != null) { 
                    this.handleResult(result);
                } else { 
                    this.logger.trace("No result object given - no result to handle");
                }
            }
    
     }
    
    		@Nullable
        protected Object doInvoke(Object... args) { 
            Object bean = this.getTargetBean();
            ReflectionUtils.makeAccessible(this.method);
    
            try { 
    						// this.method是构造adapter时传入的变量，就是被@EventListenser注解的方法
                return this.method.invoke(bean, args);
            } catch (IllegalArgumentException var6) { 
                this.assertTargetBean(this.method, bean, args);
                throw new IllegalStateException(this.getInvocationErrorMessage(bean, var6.getMessage(), args), var6);
            } catch (IllegalAccessException var7) { 
                throw new IllegalStateException(this.getInvocationErrorMessage(bean, var7.getMessage(), args), var7);
            } catch (InvocationTargetException var8) { 
                Throwable targetException = var8.getTargetException();
                if (targetException instanceof RuntimeException) { 
                    throw (RuntimeException)targetException;
                } else { 
                    String msg = this.getInvocationErrorMessage(bean, "Failed to invoke event listener method", args);
                    throw new UndeclaredThrowableException(targetException, msg);
                }
            }
        }
    
    //ApplicationListenerMethodAdapter的构造方法
    public ApplicationListenerMethodAdapter(String beanName, Class<?> targetClass, Method method) { 
            this.beanName = beanName;
    				//这个方法就是被@EventListenser注解的方法
            this.method = BridgeMethodResolver.findBridgedMethod(method);
            this.targetMethod = !Proxy.isProxyClass(targetClass) ? AopUtils.getMostSpecificMethod(method, targetClass) : this.method;
            this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);
            EventListener ann = (EventListener)AnnotatedElementUtils.findMergedAnnotation(this.targetMethod, EventListener.class);
            this.declaredEventTypes = resolveDeclaredEventTypes(method, ann);
            this.condition = ann != null ? ann.condition() : null;
            this.order = resolveOrder(this.targetMethod);
    }

总结下，ApplicationListenerMethodAdapter适配器构造时会传入被@EventListenser注解的方法，然后在onApplicationEvent()中通过反射，调用传入的方法，就实现了注解方式的事件发布。

## 结语 ##

本文简介了spring的事件驱动编程实践，以及源码实现，希望能给大家的使用提供一些借鉴。事件驱动为我们提供了一种十分优秀的解耦的手段，可以将大量复杂的业务逻辑拆分到不同的订阅者中去处理，让我们的代码更符合SRP原则。而且，spring已经为我们在java的事件基础上提供了优秀的二次封装，推荐大家在合适的业务场景中去尝试一下。

--------------------

—by eric02.li

[d9cc6bc2237c451a9f2257d4e8d7d997.png]: /images/20220829/244108ec447e4e3a8a67240843e57355.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/124e5d03a3054ef794517865f826bdac.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/10f932f2d2c14bb4a846bacbccc487f0.png
[AbstractApplicationContext]: /images/20220829/922d75b800ef4dcd8ea5deeb1b2c7efd.png
[SmartInitializingSingleton]: /images/20220829/dcfe5b4bd2fe4b73aa05f08329f84877.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25byA5Y-R6ZqP5b-D6K6w_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/0201d9ec4e1c44a192a71d50e823fa2f.png