1. 事件(ApplicationEvent):要广播,发送的消息. 监听器监听的事情
2. 监听器(ApplicationListener): 观察者模式中的观察者,监听器监听特定事件,并在内部定义了事件发生后的相应逻辑.
3. 事件发布器(ApplicationEventMulticaster):对应于观察者模式中的被观察者/主题.负责通知观察者. 对外提供发布事件和增删事件监听器的接口.维护事件和事件监听器之间的关系.并在事件发生时负责通知事件监听器.

package com.lxl.www.events;

/**
 * Description
 *
 * DATE 2020/11/17.
 *
 * @author lxl.
 */
public class Order {
    private Integer id;

    public Integer getId() {
        return id;
    }

    void setId(Integer id) {
        this.id = id;
    }
}

package com.lxl.www.events;

import org.springframework.context.ApplicationEvent;

import java.io.Serializable;

*
 * Description
 * 订单的事件
 *
 * 事件的分类: 分为自定义事件和内置事件
 * DATE 2020/11/17.
 *
 * @author lxl.
  OrderEvent  extends ApplicationEvent implements Serializable {

    private static final long serialVersionUID = 1L;

     String name;
    public OrderEvent(Object event,String name) {
        super();
        this.name = name;
    }

     String getName() {
         setName(String name) {
         name;
    }
}

package com.lxl.www.events;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

*
 * Description
 * OrderEvent的事件监听器
 *
 *
 * DATE 2020/11/17.
 *
 * @author lxl.
 */
@Component
class OrderEventListenter implements ApplicationListener<OrderEvent> {
    *
     * 当某一个事件发布的时候,就会触发事件监听器
     * @param event the event to respond to
     
    @Override
    void onApplicationEvent(OrderEvent ) {
        if (event.getName().equals("减库存")) {
            System.out.println(事件监听器  监听到  减库存);
        }
    }
}

package com.lxl.www.events;

import org.springframework.beans.factory.parsing.SourceExtractor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

*
 *  监听器的使用
  MainClass {
    static  main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.);

        *
         * 使用场景: 比如有一个订单,由用户下单了,那么对应的就要减库存.其实下单和减库存不需要是串行.
         * 通常,我们会使用一个mq去处理减库存的情况. 也就是采用异步的方式.
         *
         * 那么,监听器的远离和mq是类似的. 我们可以手动设置采用同步还是异步的方式处理.
         
        Order order = new Order();
        order.setId(1);
        System.下单// 发布事件. 当在这里发布事件,那么就会被事件监听器监听到
        ctx.publishEvent(new OrderEvent(order,));
        System.日志.....);
    }
}

下单
事件监听器  监听到  减库存
日志.....

abstract  ApplicationContextEvent extends ApplicationEvent {

    *
     * Create a new ContextStartedEvent.
     * @param source the {@code ApplicationContext} that the event is raised for
     * (must not be {@code null})
     */
     ApplicationContextEvent(ApplicationContext source) {
        super(source);
    }

    *
     * Get the {@code ApplicationContext} that the event was raised for.
      final ApplicationContext getApplicationContext() {
         (ApplicationContext) getSource();
    }

}

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
         进入构造函数,首先调用自身的构造方法this();
         调用自身的构造方法之前,要先调用父类的构造方法
        this();
         register配置注册类
        register(componentClasses);
        // ioc容器刷新接口--非常重要
        refresh();
    }

*
     * refresh是spring最核心的方法,里面包含了整个spring ioc的全过程,包括spring加载bean到销毁bean的全过程
     * 学习spring,就是学习里面的13个方法,如果13个方法都学完了,基本上就打通了
     * @throws BeansException
     * @throws IllegalStateException
      refresh() throws BeansException,IllegalStateException {
        synchronized (.startupShutdownMonitor) {
             1. 准备刷新上下文环境
            prepareRefresh();

             Tell the subclass to refresh the internal bean factory.
            2. 获取告诉子类初始化bean工厂,不同工厂不同实现
            ConfigurableListablebeanfactory beanfactory = obtainFreshbeanfactory();

　　　　　　　　......
 Last step: publish corresponding event.
                //最后容器刷新 发布刷新时间(spring cloud是从这里启动的 )
                finishRefresh();
            }
　　　　　　
　　　　　　......

　　　　}
    }

protected  finishRefresh() {
         Clear context-level resource caches (such as ASM Metadata from scanning).
         清除上下文缓存
        clearResourceCaches();

         Initialize lifecycle processor for this context.
         注册lifecycleProcessor声明周期处理器
         作用: 当ApplicationContext启动或停止时,他会通过LifecycleProcessor来与所有声明的bean进行交互
        initLifecycleProcessor();

         Propagate refresh to lifecycle processor first.
         为实现了SmartLifeCycle并且isAutoStartup,自动启动的Lifecycle调用start()方法
        getLifecycleProcessor().onRefresh();
　　　　// 发布容器启动完毕事件
        publishEvent(new ContextRefreshedEvent(this));

         Participate in LiveBeansView MBean,if active.
        LiveBeansView.registerApplicationContext();
    }

*
 * 自定义一个事件监听器,用来监听ContextRefreshedEvent事件
  ContextRefreshedEventListener {

  *
   * 声明这是一个事件监听器,监听的是ContextRefreshedEvent事件.
   * @param event
   
  @EventListener(ContextRefreshedEvent.)
  void onApplicationEvent(ContextRefreshedEvent ) {
    　　....
　　　　 在所有的bean创建完以后,写一些逻辑代码

  }
}

 doClose() {
         Check whether an actual close attempt is necessary...
        this.active.get() && this.closed.compareAndSet(false,true)) {
            if (logger.isDebugEnabled()) {
                logger.debug(Closing " + );
            }

            LiveBeansView.unregisterApplicationContext();

            try {
                // Publish shutdown event.
                publishEvent(new ContextClosedEvent(this));
            }
            catch (Throwable ex) {
                logger.warn(Exception thrown from ApplicationListener handling ContextClosedEvent Stop all Lifecycle beans,to avoid delays during individual destruction.
            this.lifecycleProcessor != null) {
                 {
                    .lifecycleProcessor.onClose();
                }
                 (Throwable ex) {
                    logger.warn(Exception thrown from LifecycleProcessor on context close Destroy all cached singletons in the context's beanfactory.
            destroyBeans();

             Close the state of this context itself.
            closebeanfactory();

             Let subclasses do some final clean-up if they wish...
            onClose();

             Reset local application listeners to pre-refresh state.
            this.earlyApplicationListeners != .applicationListeners.clear();
                this.applicationListeners.addAll(.earlyApplicationListeners);
            }

             Switch to inactive.
            set(false);
        }
    }

@Component
class HelloEventListener implements ApplicationListener<OrderEvent> {

  @Override
  ) {
      )) {
        System.减库存....);
      }
  }
}

 OrderEventListener {

  @EventListener(OrderEvent.class)
  ) {
    )) {
      System.);
    }
  }

} 

 　　　　 创建早期的事件监听器.
         Store pre-refresh ApplicationListeners...
        this.earlyApplicationListeners == ) {
            this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
        }
        else {
            .applicationListeners.clear();
            .earlyApplicationListeners);
        }

什么是早期的事件监听器呢? 早对应的就是晚了. 早期指的是多早呢?

早期事件指的是事件监听器还没有注册到事件多播器的时候.

早期定义的事件不需要手动的publishEvent,在RegisterListener()阶段会自动发布早期事件.

1. AbstractRefreshableApplicationContext: 基于xml配置文件的方式
2. GenericApplicationContext: 基于注解的方式.

基于注解实现的里面代码很简单,只是刷新的beanfactory. 没有耦合加载beanDefinition的流程.
基于xml实现的代码,里面耦合了加载beanDefinition

@Override
    protected final      refreshbeanfactory() throws IllegalStateException {
        if (!this.refreshed.compareAndSet(throw  IllegalStateException(
                    GenericApplicationContext does not support multiple refresh attempts: 
　　　　　　　　　　　　　　　　just call 'refresh' once);
        }
        // 指定bean工厂的序列化ID
        this.beanfactory.setSerializationId(getId());
    }

 refreshbeanfactory() throws BeansException {
         判断bean工厂是否初始化过,如果已经初始化过那么销毁并关闭
         (hasbeanfactory()) {
            destroyBeans();
            closebeanfactory();
        }
         重新创建一个bean工厂
            DefaultListablebeanfactory beanfactory = createbeanfactory();
             设置序列化id
            beanfactory.setSerializationId(getId());
             设置个性化属性
            customizebeanfactory(beanfactory);
            // 加载BeanDefinition
            loadBeanDefinitions(beanfactory);
            this.beanfactory = beanfactory;
        }
         (IOException ex) {
            new ApplicationContextException(I/O error parsing bean definition source for " + 
　　　　　　　　　　　　　　getDisplayName(),ex);
        }
    }

 preparebeanfactory(ConfigurableListablebeanfactory beanfactory) {
         Tell the internal bean factory to use the context's class loader etc.
         设置bean工厂的类加载器为当前的application应用的加载器
        beanfactory.setBeanClassLoader(getClassLoader());
         为bean工厂设置标准的SPEL表达式解析器对象(StandardBeanExpressionResolver)
        beanfactory.setBeanExpressionResolver( StandardBeanExpressionResolver(beanfactory.getBeanClassLoader()));
         为bean工厂设置一个PropertiesEditor属性资源编辑器(用于后面给bean对象赋值)
        beanfactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar( Configure the bean factory with context callbacks.
        *
         * 注册一个完整的ApplicationContextAwareProcessor后置处理器,用来处理ApplicationContextAware
         * ApplicationContextAwareProcessor是一个bean的后置处理器. 怎么使用呢?
         *
         * 在bean初始化完成以后,会调用一堆的bean后置处理器.
         * 在初始化的地方,其实只调用了三个bean后置处理器. 那么其他的后置处理器是什么时候调用的呢?
         * 就是在这里,这里注册了 ApplicationContextAwareProcessor.
         * 在ApplicationContextAwareProcessor#invokeAwareInterfaces方法里调用了其他的aware
         * 那么invokeAwareInterfaces方法是在哪里调用呢?
         * 是在ApplicationContextAwareProcessor#postProcessBeforeInitialization调用的
         * postProcessBeforeInitialization是在bean初始化之前会调用的后置处理器
         *
         * 然后在通过addBeanPostProcessor()方法,将bean的后置处理器添加到beanPostProcessors集合中
         */
        beanfactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

        *
         * 忽略部分接口的函数方法,在populateBean(创建bean的第二步:属性赋值)时
         * 因为下面接口都有set***方法,这些方法不特殊处理将会自动注入到容器中.
         *
         * 忽略了这么多的Aware,这是怎么回事呢? 因为Aware里面的方法都是以set开头的. 当在创建bean,设置属性的时候,* 会给带有set+属性名的方法赋值. 而Aware的这些方法要忽略掉,为什么忽略掉呢?
         *
         * 比如:EnvironmentAware 里面设置了一些环境变量,这些环境变量是不需要进行属性装配的,所以要把他们排除掉
         
        beanfactory.ignoreDependencyInterface(EnvironmentAware.);
        beanfactory.ignoreDependencyInterface(EmbeddedValueResolverAware.);
        beanfactory.ignoreDependencyInterface(ResourceLoaderAware.);
        beanfactory.ignoreDependencyInterface(ApplicationEventPublisherAware.);
        beanfactory.ignoreDependencyInterface(MessageSourceAware.);
        beanfactory.ignoreDependencyInterface(ApplicationContextAware. beanfactory interface not registered as resolvable type in a plain factory.
         MessageSource registered (and found for autowiring) as a bean.
        *
         * 将beanfactory类型的实例注册解析
         *
         * 当注册了依赖解析以后,例如当注册了对beanfactory.class的解析依赖后,* 当bean属性注入的时候,一旦检测到属性为beanfactory类型. 便会将beanfactory的实例注册解析
         * 为什么呢?
         * 比如:
         * @Autowired
         * ApplicationContext applicationContext 为什么能够自动装配,通过@Autowired引入呢? 就是在这里装配的.
         * 这个也是在注入属性popularBean的时候体现的
         *
         
        beanfactory.registerResolvableDependency(beanfactory.beanfactory);
        beanfactory.registerResolvableDependency(ResourceLoader.class,1)">);
        beanfactory.registerResolvableDependency(ApplicationEventPublisher.);
        beanfactory.registerResolvableDependency(ApplicationContext. Register early post-processor for detecting inner beans as ApplicationListeners.
        // 注册事件监听器探测器后置处理器接口,ApplicationListenerDetector 解析接口方式的监听器
        beanfactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

         Detect a LoadTimeWeaver and prepare for weaving,if found.
         (beanfactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanfactory.addBeanPostProcessor( LoadTimeWeaverAwareProcessor(beanfactory));
             Set a temporary ClassLoader for type matching.
            beanfactory.setTempClassLoader( ContextTypeMatchClassLoader(beanfactory.getBeanClassLoader()));
        }

         Register default environment beans.
        beanfactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            beanfactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment());
        }
        beanfactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            beanfactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment().getSystemProperties());
        }
        beanfactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            beanfactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,getEnvironment().getSystemEnvironment());
        }
    }

protected Object initializeBean(final String beanName,final Object bean,@Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != ) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                 在初始化完成以后,调用aware
                invokeAwareMethods(beanName,bean);
                return ;
            },getAccessControlContext());
        }
         {
            // 在初始化的时候,会调用很多的aware.
            invokeAwareMethods(beanName,bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
             在初始化之前调用bean的后置处理器
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);
        }

         调用初始化方法
            invokeInitMethods(beanName,wrappedBean,mbd);
        }
         (Throwable ex) {
             BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : ),beanName,Invocation of init method Failed 再初始化之后调用bean的后置处理器
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,1)"> wrappedBean;
    }

*
     * 这里主要有三类aware
     * @param beanName
     * @param bean
      invokeAwareMethods(final String beanName,final Object bean) {
        *
         * 在这里调用的aware只有三类,我们去beanfactory中看,他有一大堆的aware要调用,* 那么其他的aware是在哪里调用的呢?
         */
         (bean instanceof Aware) {
             实现了BeanNameAware的bean
             (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
             实现了BeanClassLoaderAware接口
            BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != ) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
             实现了beanfactoryAware
            beanfactoryAware) {
                ((beanfactoryAware) bean).setbeanfactory(AbstractAutowireCapablebeanfactory.);
            }
        }
    }

*
     * 判断bean是否实现了各种Aware
     * @param bean
      invokeAwareInterfaces(Object bean) {
         (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(.applicationContext.getEnvironment());
        }
         (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(.embeddedValueResolver);
        }
         (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(.applicationContext);
        }
        ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher( (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource( (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(.applicationContext);
        }
    }

@Override
    @Nullable
    postProcessBeforeInitialization(Object bean,String beanName) throws BeansException {
        if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
             bean;
        }

        AccessControlContext acc = ;

        ) {
            acc = .applicationContext.getbeanfactory().getAccessControlContext();
        }

        if (acc !=  {
                invokeAwareInterfaces(bean);
                 {
            invokeAwareInterfaces(bean);
        }

         bean;
    }

beanfactory.ignoreDependencyInterface(EnvironmentAware.class);
beanfactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanfactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanfactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanfactory.ignoreDependencyInterface(MessageSourceAware.class);
beanfactory.ignoreDependencyInterface(ApplicationContextAware.class);

beanfactory.registerResolvableDependency(beanfactory.class,beanfactory);
beanfactory.registerResolvableDependency(ResourceLoader.class,this);
beanfactory.registerResolvableDependency(ApplicationEventPublisher.class,this);
beanfactory.registerResolvableDependency(ApplicationContext.class,this);

@Autowired
ApplicationContext applicationContext; .

　@Override
     Object postProcessAfterInitialization(Object bean,String beanName) {
        if (bean instanceof ApplicationListener) {
             potentially not detected as a listener by getBeanNamesForType retrieval
            Boolean flag = this.singletonNames.get(beanName);
             (Boolean.TRUE.equals(flag)) {
                 singleton bean (top-level or inner): register on the fly
                
                 * 注册接口类型的监听器. 将其添加到applicationContext中
                 * 之所以要在这里在加一次,是为了处理懒加载情况
                 */
                this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
            }
            else  (Boolean.FALSE.equals(flag)) {
                 这里是处理早期事件.
                if (logger.isWarnEnabled() && !.applicationContext.containsBean(beanName)) {
                     inner bean with other scope - can't reliably process events
                    logger.warn(Inner bean '" + beanName + ' implements ApplicationListener interface " +
                            but is not reachable for event multicasting by its containing ApplicationContext because it does not have singleton scope. Only top-level listener beans are allowed to be of non-singleton scope.);
                }
                .singletonNames.remove(beanName);
            }
        }
         bean;
    }

当我们调用ctx.publishEvent())的时候. 就会去通知所有监听了OrderEvent事件的事件监听器,那么,是由谁去负责通知呢? 

就是由EventMulticaster(事件多播器)将事件播报出去的.

interface ApplicationEventMulticaster {
    void addApplicationListener(ApplicationListener<?> listener);
     addApplicationListenerBean(String listenerBeanName);
    void removeApplicationListener(ApplicationListener<?> removeApplicationListenerBean(String listenerBeanName);
     removeAllListeners();  
    void multicastEvent(ApplicationEvent );
    
*
     * AbstractApplicationEventMulticaster管理了所有的监听器.
     * 当我们注册一个监听器以后,就会通过addApplicationListener方法添加到事件多播器中.
     * @param listener the listener to add
     void addApplicationListener(ApplicationListener<?> listener) {
        synchronized (.retrievalMutex) {
             Explicitly remove target for a proxy,if registered already, in order to avoid double invocations of the same listener.
            Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
             (singletonTarget instanceof ApplicationListener) {
                .defaultRetriever.applicationListeners.remove(singletonTarget);
            }
            .defaultRetriever.applicationListeners.add(listener);
            .retrieverCache.clear();
        }
    }

void multicastEvent(final ApplicationEvent null ? eventType : resolveDefaultEventType());
        获取线程池
        Executor executor = getTaskExecutor();
         从多播器中获取所有的监听器
        for (ApplicationListener<?> listener : getApplicationListeners( 拿到了监听器
            if (executor !=  异步调用广播事件
                executor.execute(() -> invokeListener(listener,1)">));
            }
            // 同步调用广播事件
                invokeListener(listener,event);
            }
        }
    }

doInvokeListener(ApplicationListener listener,ApplicationEvent // 最终调用的是监听器的onApplicationEvent方法. 这个方法就是每一个监听器都会自定义的方法.
            listener.onApplicationEvent(event);
        }
         (ClassCastException ex) {
            String msg = ex.getMessage();
            if (msg == null || matchesClassCastMessage(msg,1)">.getClass())) {
                 Possibly a lambda-defined listener which we could not resolve the generic event type for
                 -> let's suppress the exception and just log a debug message.
                Log logger = LogFactory.getLog(getClass());
                 (logger.isTraceEnabled()) {
                    logger.trace(Non-matching event type for listener:  listener,ex);
                }
            }
            throw ex;
            }
        }
    }

 registerListeners() {
         Register statically specified listeners first.
        /**
         * 第一步,获取所有的事件监听器集合.
         * 通常,这个时候,事件监听器集合是空的,除非手动调用allApplicationListeners()注册事件监听器
         */
        for (ApplicationListener<?> listener : getApplicationListeners()) {
             将监听器注册到多播器上
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        
        /**
         * 第二步: 注册接口方式的监听器
         * 获取beanDefinition中 ApplicationListener 类型的监听器. 也就是说,使用接口方式定义的监听器
　　　　　 * 就可以在这里被注册到多播器的
         * 这里是从BeanDefinition中拿的,我们自定义了 OrderEventListenter 监听器,那么会不会拿到呢?
         * 我们知道监听器的实现有两种方式,一种是注解方式.
         * 如果OrderEventListenter采用的是接口方式,那么就可以拿到. 因为它实现了ApplicationListener.拿到了,
　　　　  * 就把监听器注册到多播器上.
         * 如果是注解方式,那就拿不到了
         *
         */
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.true,1)">);
        for (String listenerBeanName : listenerBeanNames) {
             把监听器注册到多播器上
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        
        /**
         * 第三步: 获取早期的事件,然后广播早期事件. 
         * 这些早期事件是在第一步 prepareRefresh 注册的.
         * 
         */
        Set<ApplicationEvent> earlyEventsToProcess = .earlyApplicationEvents;
         在这里将早期事件清空,清空完以后,就没有早期事件了.
        this.earlyApplicationEvents = ;
        CollectionUtils.isEmpty(earlyEventsToProcess)) {
             (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

getBeanNamesForType(ApplicationListener.class,true,false);
扫描获取ApplicationListener类型的监听器.

getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

*
 * 第三步: 获取早期的事件,然后广播早期事件. 
 * 这些早期事件是在第一步 prepareRefresh 注册的.
 * 
 
Set<ApplicationEvent> earlyEventsToProcess = .earlyApplicationEvents;
;
CollectionUtils.isEmpty(earlyEventsToProcess)) {
     (ApplicationEvent earlyEvent : earlyEventsToProcess) {
        getApplicationEventMulticaster().multicastEvent(earlyEvent);
    }
}

 finishRefresh() {
     Clear context-level resource caches (such as ASM Metadata from scanning).
        clearResourceCaches();

     Initialize lifecycle processor for this context.
     注册lifecycleProcessor声明周期处理器
        initLifecycleProcessor();

     Propagate refresh to lifecycle processor first.
        getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 发布容器refresh完毕的事件.
    // 发布的是什么事件呢? 是ContextRefreshedEvent事件.
    publishEvent(new ContextRefreshedEvent(this));

    );
}

*
     * 发布事件给所有的监听器
     * Publish the given event to all listeners.
     * @param event the event to publish (may be an {@link ApplicationEvent}
     * or a payload object to be turned into a {@link PayloadApplicationEvent})
     * @param eventType the resolved event type,if known
     * @since 4.2
     void publishEvent(Object event,1)">Event must not be null Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;

        /**
         * 第一步: 获取事件
         */
         instanceof ApplicationEvent) {
             处理接口类型的事件
            applicationEvent = (ApplicationEvent) ;
        }
         {
            applicationEvent = new PayloadApplicationEvent<>(this,1)">);
            if (eventType == ) {
                eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
            }
        }

        /**
         * 第二步: 发布事件
         */
         Multicast right now if possible - or lazily once the multicaster is initialized
        this.earlyApplicationEvents != ) {
            .earlyApplicationEvents.add(applicationEvent);
        }
        
             * 调用事件多播器,将这个事件发布出去
             * 事件多播器是什么时候注册的呢? 
　　　　　　　　* 就是在refresh()初始化的时候,调用initApplicationEventMulticaster(); 初始化的事件多播器
             
            getApplicationEventMulticaster().multicastEvent(applicationEvent,eventType);
        }

        /**
         * 第三步: 发布事件给父类容器
         */
         Publish event via parent context as well...
         发布事件给父类容器
        this.parent != .parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event,eventType);
            }
             {
                this.parent.publishEvent();
            }
        }
    }

void multicastEvent(final ApplicationEvent ));
        获取线程池
        Executor executor = 从多播器中获取所有的监听器
         拿到了监听器
            ) {
                // 异步调用广播事件
                executor.execute(() -> invokeListener(listener,1)">// 同步调用广播事件
                invokeListener(listener,1)">);
            }
        }
    }