@Configuration

@ComponentScan("com.yang.xiao.hui.ioc")

@Conditional(MyCondition.class)

public class App

{

    public static void main( String[] args )

    {

        ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class);

    }

}

@Override

    public void refresh() throws BeansException, IllegalStateException { //该方法是spring ioc的核心，下面我们主要分析每一个方法

        synchronized (this.startupShutdownMonitor) {

            // Prepare this context for refreshing.

            prepareRefresh();//1

            // Tell the subclass to refresh the internal bean factory.

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//2

            // Prepare the bean factory for use in this context.

            prepareBeanFactory(beanFactory);//3

            try {

                // Allows post-processing of the bean factory in context subclasses.

                postProcessBeanFactory(beanFactory);//4

                // Invoke factory processors registered as beans in the context.

                invokeBeanFactoryPostProcessors(beanFactory);//5

                // Register bean processors that intercept bean creation.

                registerBeanPostProcessors(beanFactory);//6

                // Initialize message source for this context.

                initMessageSource();//7

                // Initialize event multicaster for this context.

                initApplicationEventMulticaster();//8

                // Initialize other special beans in specific context subclasses.

                onRefresh();//9

                // Check for listener beans and register them.

                registerListeners();//10

                // Instantiate all remaining (non-lazy-init) singletons.

                finishBeanFactoryInitialization(beanFactory);//11

                // Last step: publish corresponding event.

                finishRefresh();//12

            }

            catch (BeansException ex) {

                if (logger.isWarnEnabled()) {

                    logger.warn("Exception encountered during context initialization - " +

                            "cancelling refresh attempt: " + ex);

                }

                // Destroy already created singletons to avoid dangling resources.

                destroyBeans();

                // Reset 'active' flag.

                cancelRefresh(ex);

                // Propagate exception to caller.

                throw ex;

            }

            finally {

                // Reset common introspection caches in Spring's core, since we

                // might not ever need metadata for singleton beans anymore...

                resetCommonCaches();

            }

        }

    }

protected void prepareRefresh() {

        // Switch to active.

        this.startupDate = System.currentTimeMillis(); //记录一下启动时间，是一个时间戳

        this.closed.set(false); //将applicationContext状态设置非关闭

        this.active.set(true);  //将applicationContext状态设置已激活

        if (logger.isDebugEnabled()) {

            if (logger.isTraceEnabled()) {

                logger.trace("Refreshing " + this);

            }

            else {

                logger.debug("Refreshing " + getDisplayName());

            }

        }

        // Initialize any placeholder property sources in the context environment.

        initPropertySources(); //这个是留给子类去实现的，目前没做任何东东

        // Validate that all properties marked as required are resolvable:

        // see ConfigurablePropertyResolver#setRequiredProperties

        getEnvironment().validateRequiredProperties(); //这里做了2个工作，一个是创建一个环境对象StandardEnvironment，另一个是校验必须的属性是否在环境变量中存在，不存在就抛异常MissingRequiredPropertiesException

        // Store pre-refresh ApplicationListeners...

        if (this.earlyApplicationListeners == null) { //会尽量这里，默认是空

            this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);//applicationListeners 为空集合

        }

        else {

            // Reset local application listeners to pre-refresh state.

            this.applicationListeners.clear(); //重新设置applicationListeners内容

            this.applicationListeners.addAll(this.earlyApplicationListeners);

        }

        // Allow for the collection of early ApplicationEvents,

        // to be published once the multicaster is available...

        this.earlyApplicationEvents = new LinkedHashSet<>(); //收集早期的事件，一旦事件派发器可以使用，就派发这些事件

    }

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

        // Tell the internal bean factory to use the context's class loader etc. //设置类加载器，表达式解析器，资源相关的处理器

        beanFactory.setBeanClassLoader(getClassLoader());

        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // Configure the bean factory with context callbacks. //添加了一个后者处理器，添加忽略接口，这个忽略接口的本意我还不知道，并非是说你使用@Autowired注入这些接口，就会被忽略

        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

        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 interface not registered as resolvable type in a plain factory.

        // MessageSource registered (and found for autowiring) as a bean.
　　　　　//下面这些resolvabelDependency的意思是，我要注入一个接口作为属性，如果该接口有很多实现类，此时不知道注入哪一个实现类，通过下面的方法可以指定要注入的对象，例如BeanFactory有很多实现类
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

        beanFactory.registerResolvableDependency(ResourceLoader.class, this);

        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        // Register early post-processor for detecting inner beans as ApplicationListeners. //这里新增了一个后置处理器，用于检测内部的的ApplicationListener

        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found. //这个是用于类加载阶段进行AOP切入，而我们平时用的cglib或jdk动态代理是运行期切入

        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

            // Set a temporary ClassLoader for type matching.

            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

        }

        // Register default environment beans. //向容器中注册了3个环境相关的bean

        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

        }

        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

        }

        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

        }

    }

    @Nullable

    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { //在bean 的init方法调用前执行

        AccessControlContext acc = null;

        if (System.getSecurityManager() != null &&

                (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||

                        bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||

                        bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {

            acc = this.applicationContext.getBeanFactory().getAccessControlContext();

        }

        if (acc != null) {

            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {

                invokeAwareInterfaces(bean);

                return null;

            }, acc);

        }

        else {

            invokeAwareInterfaces(bean); //执行对应的Aware属性赋值

        }

        return bean;

    }

    private void invokeAwareInterfaces(Object bean) {

        if (bean instanceof Aware) {

            if (bean instanceof EnvironmentAware) {

                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());

            }

            if (bean instanceof EmbeddedValueResolverAware) {

                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);

            }

            if (bean instanceof ResourceLoaderAware) {

                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);

            }

            if (bean instanceof ApplicationEventPublisherAware) {

                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);

            }

            if (bean instanceof MessageSourceAware) {

                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);

            }

            if (bean instanceof ApplicationContextAware) {

                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);

            }

        }

    }

public Object postProcessAfterInitialization(Object bean, String beanName) { //这个是init()方法执行后处理的

        if (bean instanceof ApplicationListener) { //判断指定的bean是否监听器

            // potentially not detected as a listener by getBeanNamesForType retrieval

            Boolean flag = this.singletonNames.get(beanName); //获取指定的bean是否单例

            if (Boolean.TRUE.equals(flag)) {

                // singleton bean (top-level or inner): register on the fly

                this.applicationContext.addApplicationListener((ApplicationListener<?>) bean); //收集监听器

            }

            else if (Boolean.FALSE.equals(flag)) {

                if (logger.isWarnEnabled() && !this.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.");

                }

                this.singletonNames.remove(beanName);

            }

        }

        return bean;

    }

public static void invokeBeanFactoryPostProcessors(

            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

        // Invoke BeanDefinitionRegistryPostProcessors first, if any. 优先执行 BeanDefinitionRegistryPostProcessors

        Set<String> processedBeans = new HashSet<>();//已经执行过的处理器，防止重复执行

        if (beanFactory instanceof BeanDefinitionRegistry) {

            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); //普通的beanFactory后置处理器

            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();//收集BeanDefinitionRegistryPostProcessor

            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { //参数传过来的

                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

                    BeanDefinitionRegistryPostProcessor registryProcessor =

                            (BeanDefinitionRegistryPostProcessor) postProcessor;

                    registryProcessor.postProcessBeanDefinitionRegistry(registry); //如果是BeanDefinitionRegistryPostProcessor就直接执行

                    registryProcessors.add(registryProcessor);

                }

                else {

                    regularPostProcessors.add(postProcessor); //如果是普通的就收集

                }

            }

            // Do not initialize FactoryBeans here: We need to leave all regular beans

            // uninitialized to let the bean factory post-processors apply to them!

            // Separate between BeanDefinitionRegistryPostProcessors that implement

            // PriorityOrdered, Ordered, and the rest.

            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); //当前需要执行的BeanDefinitionRegistryPostProcessor

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. //首先是执行实现PriorityOrdered的后置处理器

            String[] postProcessorNames =

                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

            for (String ppName : postProcessorNames) {

                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                    processedBeans.add(ppName);

                }

            }

            sortPostProcessors(currentRegistryProcessors, beanFactory); //排序

            registryProcessors.addAll(currentRegistryProcessors);//收集起来

            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); //遍历调用

            currentRegistryProcessors.clear(); //清空当前已经执行过的后置处理器集合

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered. //同样的方式处理实现Ordered接口的BeanDefinitionRegistryPostProcessor

            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

            for (String ppName : postProcessorNames) {

                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {

                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                    processedBeans.add(ppName);

                }

            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);

            registryProcessors.addAll(currentRegistryProcessors);

            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

            currentRegistryProcessors.clear();

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.  //最后处理没有实现PriorityOrdered或者Ordered接口的BeanDefinitionRegistryPostProcessors

            boolean reiterate = true;

            while (reiterate) {

                reiterate = false;

                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

                for (String ppName : postProcessorNames) {

                    if (!processedBeans.contains(ppName)) {

                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                        processedBeans.add(ppName);

                        reiterate = true;

                    }

                }

                sortPostProcessors(currentRegistryProcessors, beanFactory);

                registryProcessors.addAll(currentRegistryProcessors);

                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

                currentRegistryProcessors.clear();

            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.

            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); //因为BeanDefinitionRegistryPostProcessor 继承了BeanFactoryPostProcessor，所以这里是执行后者的方法

            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

        }

        else {

            // Invoke factory processors registered with the context instance.

            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans  //
        
        //前面执行完所有的BeanDefinitionRegistryPostProcessor，剩下要执行 BeanFactoryPostProcessor的方法，也要分实现PriorityOrdered,实现Ordered,和没有实现这2者的情况

        // uninitialized to let the bean factory post-processors apply to them!

        String[] postProcessorNames =

                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,

        // Ordered, and the rest.

        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

        List<String> orderedPostProcessorNames = new ArrayList<>();

        List<String> nonOrderedPostProcessorNames = new ArrayList<>();

        for (String ppName : postProcessorNames) {

            if (processedBeans.contains(ppName)) {

                // skip - already processed in first phase above

            }

            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

            }

            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

                orderedPostProcessorNames.add(ppName);

            }

            else {

                nonOrderedPostProcessorNames.add(ppName);

            }

        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.执行实现PriorityOrdered

        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered. 执行实现Ordered接口的

        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();

        for (String postProcessorName : orderedPostProcessorNames) {

            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

        }

        sortPostProcessors(orderedPostProcessors, beanFactory);

        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors. 执行没有实现order接口的

        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();

        for (String postProcessorName : nonOrderedPostProcessorNames) {

            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

        }

        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        // Clear cached merged bean definitions since the post-processors might have

        // modified the original metadata, e.g. replacing placeholders in values...

        beanFactory.clearMetadataCache();

}

public static void registerBeanPostProcessors(

            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); //获取所有的BeanPostProcessor

        // Register BeanPostProcessorChecker that logs an info message when

        // a bean is created during BeanPostProcessor instantiation, i.e. when

        // a bean is not eligible for getting processed by all BeanPostProcessors.

        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; //这里加1是因为下面添加了一个BeanPostProcessorChecker

        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

        // Separate between BeanPostProcessors that implement PriorityOrdered,

        // Ordered, and the rest.
　　　　　//分组处理，分成4组　


        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

        List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();

        List<String> orderedPostProcessorNames = new ArrayList<>();

        List<String> nonOrderedPostProcessorNames = new ArrayList<>();

        for (String ppName : postProcessorNames) {

            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

                priorityOrderedPostProcessors.add(pp);

                if (pp instanceof MergedBeanDefinitionPostProcessor) {

                    internalPostProcessors.add(pp);

                }

            }

            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

                orderedPostProcessorNames.add(ppName);

            }

            else {

                nonOrderedPostProcessorNames.add(ppName);

            }

        }

        // First, register the BeanPostProcessors that implement PriorityOrdered.

        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);   //排序

        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); //保存到容器

        // Next, register the BeanPostProcessors that implement Ordered. //处理Ordered

        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();

        for (String ppName : orderedPostProcessorNames) {

            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

            orderedPostProcessors.add(pp);

            if (pp instanceof MergedBeanDefinitionPostProcessor) {

                internalPostProcessors.add(pp);

            }

        }

        sortPostProcessors(orderedPostProcessors, beanFactory); //排序

        registerBeanPostProcessors(beanFactory, orderedPostProcessors); //注册到beanFactory

        // Now, register all regular BeanPostProcessors.

        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();

        for (String ppName : nonOrderedPostProcessorNames) {

            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

            nonOrderedPostProcessors.add(pp);

            if (pp instanceof MergedBeanDefinitionPostProcessor) {

                internalPostProcessors.add(pp);

            }

        }

        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

        // Finally, re-register all internal BeanPostProcessors.

        sortPostProcessors(internalPostProcessors, beanFactory); //排序

        registerBeanPostProcessors(beanFactory, internalPostProcessors);

        // Re-register post-processor for detecting inner beans as ApplicationListeners,

        // moving it to the end of the processor chain (for picking up proxies etc).

        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); //这里重新添加了这个ApplicationListenerDetector，是为了让它排在最后

    }

protected void initMessageSource() {

        ConfigurableListableBeanFactory beanFactory = getBeanFactory();

        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {  //先判断容器中有没对应的bean

            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);

            // Make MessageSource aware of parent MessageSource.

            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {

                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;

                if (hms.getParentMessageSource() == null) {

                    // Only set parent context as parent MessageSource if no parent MessageSource

                    // registered already.

                    hms.setParentMessageSource(getInternalParentMessageSource());//设置父容器的MessageSource

                }

            }

            if (logger.isTraceEnabled()) {

                logger.trace("Using MessageSource [" + this.messageSource + "]");

            }

        }

        else {

            // Use empty MessageSource to be able to accept getMessage calls.

            DelegatingMessageSource dms = new DelegatingMessageSource(); //容器中不存在，就新创建一个，然再将其放到ioc中

            dms.setParentMessageSource(getInternalParentMessageSource());

            this.messageSource = dms;

            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

            if (logger.isTraceEnabled()) {

                logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");

            }

        }

    }

protected void initApplicationEventMulticaster() {

        ConfigurableListableBeanFactory beanFactory = getBeanFactory();

        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { //容器中已存在就直接获取

            this.applicationEventMulticaster =

                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);

            if (logger.isTraceEnabled()) {

                logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");

            }

        }

        else {

            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);//容器中不存在就创建

            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

            if (logger.isTraceEnabled()) {

                logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +

                        "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");

            }

        }

    }

    protected void registerListeners() {

        // Register statically specified listeners first.

        for (ApplicationListener<?> listener : getApplicationListeners()) {

            getApplicationEventMulticaster().addApplicationListener(listener); //将已存在的监听器加到事件派发器中

        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans

        // uninitialized to let post-processors apply to them!

        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);//从容器中获取所有的监听器

        for (String listenerBeanName : listenerBeanNames) {

            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);////将已存在的监听器加到事件派发器中

        }

        // Publish early application events now that we finally have a multicaster...

        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; //获取所有早期的事件

        this.earlyApplicationEvents = null;

        if (earlyEventsToProcess != null) {

            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {

                getApplicationEventMulticaster().multicastEvent(earlyEvent);//派发事件

            }

        }

    }

protected void finishRefresh() {

        // Clear context-level resource caches (such as ASM metadata from scanning).

        clearResourceCaches(); //清除缓存

        // Initialize lifecycle processor for this context.

        initLifecycleProcessor(); //初始化LifecycleProcessor

        // Propagate refresh to lifecycle processor first.

        getLifecycleProcessor().onRefresh();//调用LifecycleProcessor的OnRefresh()方法

        // Publish the final event.

        publishEvent(new ContextRefreshedEvent(this));//派发上下文刷新事件

        // Participate in LiveBeansView MBean, if active.

        LiveBeansView.registerApplicationContext(this); //MBean 不清楚啥作用

    }