@EventListener注解 -【Spring底层原理】

以你之姓@ 2021-09-21 21:38 412阅读 0赞

**目录**

一、注解用法

二、实例分析

三、源码分析

四、总结

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

> 上篇我们讲到实现事件监听可以使用实现ApplicationListener接口 [Spring中ApplicationListener -【Spring底层原理】][Spring_ApplicationListener -_Spring]，如果有多个方法需要监听事件，那岂不是每个方法都要放在类中实现ApplicationListener接口，这样并不是很方便，所以spring为我们提供了另外一种方式实现事件监听：使用@EventListener注解

## 一、注解用法 ##

注解源码如下，有如下作用：

*  可以作用在方法
 *  参数可以是class数组，可以写多个事件
 *  使用了该注解的方法，当容器中发布事件后，该方法会触发，类似实现ApplicationListener接口

/*
     * @author Stephane Nicoll
     * @author Sam Brannen
     * @since 4.2
     * @see EventListenerMethodProcessor
     */
    @Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface EventListener {
    
    	@AliasFor("classes")
    	Class<?>[] value() default {};
    
    	@AliasFor("value")
    	Class<?>[] classes() default {};
    
    	String condition() default "";
    }

从注释可以看到是使用`EventListenerMethodProcessor`这个处理器来解析方法上的`EventListener`注解，`EventListenerMethodProcessor`主要则是通过其实现的接口`SmartInitializingSingleton`来进行处理的，后面会分析其源码。

## 二、实例分析 ##

// 启动测试类
    @Test
    public void TestMain(){
        // 创建IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        // 自己发布一个事件
        applicationContext.publishEvent(new ApplicationEvent("自己发布的事件") {
        });
        applicationContext.close();
    }
    
    // 事件触发
    @Service
    public class UserService {
        // 当容器中发布事件后，该方法会触发
        @EventListener(classes = {ApplicationEvent.class})
        public void listener1(ApplicationEvent event){
            System.out.println("监听到的事件1：" + event);
        }
        @EventListener(classes = {ApplicationEvent.class})
        public void listener2(ApplicationEvent event){
            System.out.println("监听到的事件2：" + event);
        }
    }
    
    // 配置类
    @ComponentScan("listener")
    @Configuration
    public class AppConfig {
    }

运行启动类，可以看到，两个事件都被触发了，使用@EventListener注解，方便让多个方法触发

![image-20210324135958362][]

## 三、源码分析 ##

上面讲到是使用`EventListenerMethodProcessor`这个处理器来解析方法上的EventListener注解，点进`EventListenerMethodProcessor`查看，发现实现了`SmartInitializingSingleton`接口，主要就是通过该接口实现的。

public class EventListenerMethodProcessor implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {}

public interface SmartInitializingSingleton {
    
       /**
        * Invoked right at the end of the singleton pre-instantiation phase,
        * with a guarantee that all regular singleton beans have been created
        * already. {@link ListableBeanFactory#getBeansOfType} calls within
        * this method won't trigger accidental side effects during bootstrap.
        * <p><b>NOTE:</b> This callback won't be triggered for singleton beans
        * lazily initialized on demand after {@link BeanFactory} bootstrap,
        * and not for any other bean scope either. Carefully use it for beans
        * with the intended bootstrap semantics only.
        */
       void afterSingletonsInstantiated();
    
    }

`SmartInitializingSingleton`接口有个`afterSingletonsInstantiated`方法，当单实例bean全部创建完成，会触发这个接口，执行`afterSingletonsInstantiated`方法，类似于`ContextRefreshedEvent`

我们在`afterSingletonsInstantiated`方法上打上断点，看看源码是何时调用该方法执行的。

![image-20210324144953217][]

通过方法调用栈，容器创建对象，调用refresh()方法刷新容器——>finishBeanFactoryInitialization(beanFactory)——>preInstantiateSingletons()初始化剩下的单实例bean

*  创建所有的单实例bean
 *  获取所有创建好的单实例bean，判断各bean是否是SmartInitializingSingleton类型的
 *  如果是则调用afterSingletonsInstantiated方法

这里便到了我们上面分析的SmartInitializingSingleton\#afterSingletonsInstantiated方法，也就是@EventListener注解注解起作用的地方

@Override
    public void preInstantiateSingletons() throws BeansException {
       if (logger.isTraceEnabled()) {
          logger.trace("Pre-instantiating singletons in " + this);
       }
    
       // Iterate over a copy to allow for init methods which in turn register new bean definitions.
       // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
       List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
       // 遍历beanName，创建bean，即非懒加载单实例bean的初始化
       for (String beanName : beanNames) {
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
             if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                   FactoryBean<?> factory = (FactoryBean<?>) bean;
                   boolean isEagerInit;
                   if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                      isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                   }
                   else {
                      isEagerInit = (factory instanceof SmartFactoryBean &&
                            ((SmartFactoryBean<?>) factory).isEagerInit());
                   }
                   if (isEagerInit) {
                      getBean(beanName);
                   }
                }
             }
             else {
                // 创建对象
                getBean(beanName);
             }
          }
       }
    
       // Trigger post-initialization callback for all applicable beans...
       // 创建完bean后判断各bean是否实现了SmartInitializingSingleton，如果是则执行 smartSingleton.afterSingletonsInstantiated()方法
       for (String beanName : beanNames) {
          Object singletonInstance = getSingleton(beanName);
          if (singletonInstance instanceof SmartInitializingSingleton) {
             StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                   .tag("beanName", beanName);
             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
             if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                   // 执行afterSingletonsInstantiated
                   smartSingleton.afterSingletonsInstantiated();
                   return null;
                }, getAccessControlContext());
             }
             else {
                smartSingleton.afterSingletonsInstantiated();
             }
             smartInitialize.end();
          }
       }
    }

## 四、总结 ##

1.  IOC容器创建对象并refresh刷新
2.  finishBeanFactoryInitialization(beanFactory)——>preInstantiateSingletons()初始化剩下的单实例bean
    
    1.  创建所有的单实例bean
    2.  获取所有创建好的单实例bean，判断各bean是否是SmartInitializingSingleton类型的
    3.  如果是则调用afterSingletonsInstantiated方法

[Spring_ApplicationListener -_Spring]: https://mp.weixin.qq.com/s?__biz=MzU2MDQ2MTE5MA==&mid=2247484429&idx=1&sn=3379359eed140336fe87ee5d3b958d19&chksm=fc06e0e4cb7169f2a062e3b20c495629419c19f3788d06478bcb83afb969910db43e498cafc6&token=965828964&lang=zh_CN#rd
[image-20210324135958362]: /images/20210920/999949c0f1ed4b3f86d2b0d593758b2b.png
[image-20210324144953217]: /images/20210920/dbd92fabe2194fee89e04b8391e6397c.png