spring5.x-监听器原理及源码实现

...
//创建初始化事件监听器
if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
      // Reset local application listeners to pre-refresh state.
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    /** 初始化事件列表，自动将初始化事件监听器（自动添加不需要pubish）
     */
    this.earlyApplicationEvents = new LinkedHashSet<>();

...
//注册后置处理器用来处理ApplicationContextAware接口的回调方法
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
...

...
// 注册事件多播器
        initApplicationEventMulticaster();

...
//事件监听器注册到多播器上
        registerListeners();

/**事件多播器初始化 **/
protected void initApplicationEventMulticaster() {
    //获取bean工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果没有多播器则应用多播器组件
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
      //获取bean中的对象（提前初始化的）
      this.applicationEventMulticaster =
          beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
      }
    }
    //如果没有多播器
    else {
      //初始化简单的多播器
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      //注入到容器中
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
            APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
            "': using default [" + this.applicationEventMulticaster + "]");
      }
    }
  }

/**初始化和懒加载都会调用注册 **/
protected void registerListeners() {
    //获取所有监听器对象 
    for (ApplicationListener<?> listener : getApplicationListeners()) {
      //把监听器注册到多播器上
      getApplicationEventMulticaster().addApplicationListener(listener);
    }

    //获取自定的监听器
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    //同样把自定义的监听器注册到多播器中
    for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    //获取初始化监听器
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    //将所有初始化的监听器置为空并进行广播（清空掉）
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
      //通过多播器进行播发早期事件
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
        getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
    }
  }

...
// 发布事件多播器
    publishEvent(new ContextRefreshedEvent(this));
...

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");
    if (logger.isTraceEnabled()) {
      logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    }

    // 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();
      }
    }

    //发布初始化(早期)事件，唯一的地方
    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 void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
  ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  //获取所有监听器
  for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
    //获取异常支持，有则是异常事件，否则是同步发
    Executor executor = getTaskExecutor();
    if (executor != null) {
      //异步播发事件
      executor.execute(() -> invokeListener(listener, event));
    }
    else {//同步发
      invokeListener(listener, event);
    }
  }
}