两种监听方式

在Spring中，如果要进行事件监听有两种方式：一种是实现ApplicationListener接口，另一种就是在方法上加@EventListener注解。

@Component
public class MyListener implements ApplicationListener<ApplicationEvent> {

    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        System.out.println("I got it!");
    }
}

@Component
public class MethodListener {

    @EventListener(classes = ApplicationEvent.class)
    public void listen() {
        System.out.println("I got it!");
    }
}

EventListenerMethodProcessor

那么原理是什么呢？ 查看EventListener注解源码，阅读一番后，我们注意到了一个关键类：EventListenerMethodProcessor。看一下源码：

public class EventListenerMethodProcessor
      implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
    //...
}

通过注释我们可以得知，EventListenerMethodProcessor类的目的就是为了把EventListener注解方法注册成ApplicationListener实例。 除去我们常见的ApplicationContextAware,BeanFactoryPostProcessor两位”老友“，剩下有点不熟悉的就是SmartInitializingSingleton了。

SmartInitializingSingleton

/**
 * Callback interface triggered at the end of the singleton pre-instantiation phase during
 * {@link BeanFactory} bootstrap. 
 * ...
/
public interface SmartInitializingSingleton {
   void afterSingletonsInstantiated();
}

SmartInitializingSingleton接口也很简单，就一个方法。通过注释我们可以得知，它的作用时机就是在单例完成pre-instantiation阶段后作为一个回调接口被触发。这个pre-instantiation，如果看过容器刷新（refresh）的小伙伴们，应该对它非常熟悉。

//AbstractApplicationContext
@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
    
      prepareRefresh();
      // ...
        try {
           // ...
        
           // Instantiate all remaining (non-lazy-init) singletons.
           // 在这里
           finishBeanFactoryInitialization(beanFactory);

           // Last step: publish corresponding event.
           finishRefresh();
        }catch(BeanException ex){
            //...
        }
}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   
   // ...
   // Instantiate all remaining (non-lazy-init) singletons.
   beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {
    // ...
    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
       Object singletonInstance = getSingleton(beanName);
       if (singletonInstance instanceof SmartInitializingSingleton) {
          final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
          if (System.getSecurityManager() != null) {
             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                smartSingleton.afterSingletonsInstantiated();
                return null;
             }, getAccessControlContext());
          }
          else {
             smartSingleton.afterSingletonsInstantiated();
          }
       }
    }
}

没错就是在这里调用了afterSingletonsInstantiated方法。我们看看EventListenerMethodProcessor的afterSingletonsInstantiated方法干了什么。

再探EventListenerMethodProcessor

//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)) {
         // ...
         if (type != null) {
            // ...
            try {
               processBean(beanName, type);
            }
            catch (Throwable 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) {
        // ...
      }

      if (CollectionUtils.isEmpty(annotatedMethods)) {
        // ...
      }
      else {
         // Non-empty set of methods
         ConfigurableApplicationContext context = this.applicationContext;
         Assert.state(context != null, "No ApplicationContext set");
         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;
               }
            }
         }
        // ...
      }
   }
}

里面内容很多，咱们直接看重点。从第27行到第32行可以看出，主要目的就是对所有的bean进行检查，找到带有EventListener注解的方法。从第50行到第56行可以看出，就是利用找到的这些方法创建监听器，然后加入容器中。这里也非常巧妙地使用了适配器模式，ApplicationListenerMethodAdapter就是做适配的。 我们再来看看这些方法是如何被使用的呢？

//ApplicationListenerMethodAdapter
@Override
public void onApplicationEvent(ApplicationEvent event) {
   processEvent(event);
}
public void processEvent(ApplicationEvent event) {
   Object[] args = resolveArguments(event);
   if (shouldHandle(event, args)) {
      Object result = doInvoke(args);
      // ...
   }
}
@Nullable
protected Object doInvoke(Object... args) {
   Object bean = getTargetBean();
   // ...
   try {
      return this.method.invoke(bean, args);
   }
   // ...
}

可以看到当监听到事件后就会执行onApplicationEvent方法，然后去容器中找到这些bean，利用反射执行这些方法。

总结

在容器刷新的倒数第二步中会执行bean中所有实现了SmartInitializingSingleton接口的afterSingletonsInstantiated方法。EventListenerMethodProcessor类重写了该方法，获取所有bean中带有EventListener注解的方法，并使用ApplicationListenerMethodAdapter进行适配，当监听到事件时就执行该方法。

《完》