sping ioc 源码分析（二）-- refresh()方法分析

测试环境代码：

@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);

    }
}

debug调试启动过程：本次主要分析refresh（）方法：

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

1. prepareRefresh(); // Prepare this context for refreshing. 为调用后续的方法进行准备工作

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<>(); //收集早期的事件，一旦事件派发器可以使用，就派发这些事件
    }

 小结：prepareRefresh() 主要是为刷新工作做了些准备：设置context的状态，创建环境对象，初始化一些早期的事件监听器和事件

 2.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 

 

 小结：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 方法作用是：刷新bean工厂，并将并工厂返回去，这个bean工厂是在GenericApplicationContext的构造方法进行初始化的

 

 3.prepareBeanFactory(beanFactory);  //Prepare the bean factory for use in this context. 对beanFactory做一些初始化操作

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

 prepareBeanFactory 新增了2个后置处理器：ApplicationContextAwareProcessor 该后置处理器是处理实现Aware接口的bean的对应属性赋值：

    @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);
            }
        }
    }

prepareBeanFactory 新增的另一个后置处理器ApplicationListenerDetector用于检测某个单例的bean是否是监听器

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;
    }

   小结： prepareBeanFactory方法主要给beanFactory 设置了类加载器，环境相关的bean，2个后置处理器，以及一些忽略接口和可提前解析的接口

 4. postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) //  Allows post-processing of the bean factory in context subclasses.这个是留给子类去实现的

  子类可以重写该方法，在beanFactory标准初始化后（方法3是对其进行初始化），对其进行修改，所有的bean定义信息都被加载，但还没有bean被实例化，这个方法也允许，往beanFactory中添加特殊的后置处理器

 5.invokeBeanFactoryPostProcessors(beanFactory);  按顺序执行BeanFactoryPostProcessor接口的相应方法，在此我们分析下BeanFactoryPostProcessor,BeanDefinitionRegistryPostProcessor,BeanPostProcessor 三者区别

       先看BeanFactoryPostProcessor，允许我们对beanFactory做一些修改，例如新增或者覆盖一些属性，甚至更早的初始化一些bean

 在这一步里，调用了一个核心的类ConfigurationClassPostProcessor，将@component等注解标注的类定义信息扫描到ioc容器中了，具体参考博客：https://www.cnblogs.com/yangxiaohui227/p/13431628.html

 接着我们看：BeanDefinitionRegistryPostProcessor 它继承了BeanFactoryPostProcessor，提供了一个方法，给我可以修改Bean的定义信息机会，例如将一个A类的BeanDefinition的类属性改成B类

 最后我们看看BeanPostProcessor，这个是用于普通bean的生命周期逻辑处理，例如，init()方法执行前后

 invokeBeanFactoryPostProcessors(beanFactory);//针对的是下BeanFactoryPostProcessor,BeanDefinitionRegistryPostProcessor

对于一组PostProcessors，他们执行需要一个顺序，这里就会涉及到PriorityOrdered 和Ordered接口，所以执行的顺序是，实现PriorityOrdered-->实现Ordered--》普通的，而BeanFactoryPostProcessor,BeanDefinitionRegistryPostProcessor

的执行顺序是先执行BeanDefinitionRegistryPostProcessor，然后再到BeanFactoryPostProcessor，有了上面的知识，我们开始分析源码：

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

小结：invokeBeanFactoryPostProcessors的逻辑是分组，并按照不同的顺序执行BeanFactoryPostProcessors

 6. registerBeanPostProcessors(beanFactory)；//注册BeanPostProcessors用于后面拦截Bean的创建过程

 这里的逻辑是，获取所有的BeanPostProcessors，然后也跟方法5一样，分优先级，实现PriorityOrdered->internal->实现Ordered接口->普通的

之后按顺序将它们存到：DefaultListableBeanFactory 父类的一个集合中：List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

具体源码：

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，是为了让它排在最后
    }

我们看看注册方法：

 

 7.initMessageSource();  // Initialize message source for this context. 初始化专门处理国际化的bean

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 + "]");
            }
        }
    }

小结，上面仅仅是向容器中注入了一个message bean

 8.initApplicationEventMulticaster(); // 初始化事件派发器，该对象存有一个list,值的内容是监听器，里面还有个发布事件的方法，发布事件时，遍历监听器，调用每个监听器去处理该事件

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() + "]");
            }
        }
    }

9.onRefresh(); 该方法是留给子类实现，在springboot内嵌tomcat的实现原理中，就是在该方法进行初始化tomcat容器的

10.registerListeners(); //主要逻辑是添加监听器到事件派发器中，然后派发事件

 
    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);//派发事件
            }
        }
    }

11.finishBeanFactoryInitialization(beanFactory);//完成所有的非懒加载的类实例化，这里是核心，请参考另一篇博客：https://www.cnblogs.com/yangxiaohui227/p/13438849.html

12.finishRefresh();//完成刷新，发布相关的事件

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 不清楚啥作用
    }

 至此，启动核心源码分析完毕