Spring扩展原理

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
   // 处理事件
   void onApplicationEvent(E event);
}

@EventListener(classes = {ApplicationEvent.class})
public void listenEvent(ApplicationEvent applicationEvent) {
    System.out.println("MonkeyService -> listenEvent");
    System.out.println("    > received event : " + applicationEvent);
}

applicationContext.publishEvent(Object event);

protected void finishRefresh() {
    this.clearResourceCaches();
    this.initLifecycleProcessor();
    this.getLifecycleProcessor().onRefresh();
    this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this))); (1)
    LiveBeansView.registerApplicationContext(this);
}

protected void doClose() {
    if (this.active.get() && this.closed.compareAndSet(false, true)) {
        if (logger.isDebugEnabled()) {
            logger.debug("Closing " + this);
        }
        LiveBeansView.unregisterApplicationContext(this);
        try {
            // 发布容器关闭事件
            publishEvent(new ContextClosedEvent(this));
        }
        catch (Throwable ex) {
            logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
        }
        // 省略其他代码
    }
}

getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    Executor executor = getTaskExecutor(); (2)
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) { (1)
        if (executor != null) {
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
            invokeListener(listener, event); (3)
        }
    }
}

listener.onApplicationEvent(event);

protected void registerListeners() {
    // 注册监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    // ...
}

public interface SmartInitializingSingleton {
   // 在单例预实例化阶段结束时调用，并保证已经创建了所有常规单例bean。
   // 此方法中的ListableBeanFactory.getBeansOfType调用不会在引导期间触发意外的副作用。
   // 注意：对于在BeanFactory引导后按需延迟初始化的singleton bean，以及任何其他bean作用域，都不会触发此回调。小心地将它仅用于具有预期引导语义的bean。
   void afterSingletonsInstantiated();
}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // ...
    // 初始化单实例bean
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    beanFactory.setTempClassLoader(null);
    beanFactory.freezeConfiguration();
    // 初始化所有剩余的单例bean
    beanFactory.preInstantiateSingletons();
}

public void preInstantiateSingletons() throws BeansException {
   // ...
   // 省略实例化单例bean代码

   // 实例化完成后回调 SmartInitializingSingleton 接口
   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();
         }
      }
   }
}