基于AnnotationConfigApplicationContext的容器创建过程（Spring Version 5.2.0）

首先你要引入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

然后你得有个配置类

import org.springframework.context.annotation.Configuration;

@Configuration
public class SimpleConfig {
}

最后是启动程序

public static void main(String[] args){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SimpleConfig.class);
}

开始

进入构造方法

public AnnotationConfigApplicationContext(Class... componentClasses) {
    this();
    this.register(componentClasses);
    this.refresh();
}

这种情况分为三步：

1. 调用重载构造方法，目的是初始化bean定义扫描器。

public AnnotationConfigApplicationContext() {
    // 这是{ClassPathBeanDefinitionScanner}的另一种选择，它应用了相同的注释解析，但是只针对显式注册的类。
    this.reader = new AnnotatedBeanDefinitionReader(this);
    // 一个bean定义扫描器，它检测类路径上的候选bean，在给定的注册中心注册相应的bean定义({BeanFactory}或{ApplicationContext})。
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

2. 注册给定的配置类

public void register(Class... componentClasses) {
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    // 实际上调用AnnotatedBeanDefinitionReader#doRegisterBean，注册给定的bean
    this.reader.register(componentClasses);
}

3. 刷新。

// 实际上调用的父类刷新方法
org.springframework.context.support.AbstractApplicationContext#refresh

refresh方法

先看下整个流程

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 为上下文刷新做准备：设置其启动开始时间和活动标志以及执行任何属性源的初始化。初始化earlyApplicationListeners和earlyApplicationEvents。
        prepareRefresh();

        // 2. 告诉子类刷新内部bean工厂。返回这个上下文所持有的内部BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // ☆☆☆3. 准备bean工厂以供在此上下文中使用。配置工厂的标准上下文特征，比如上下文的类加载器、后置处理器。
        prepareBeanFactory(beanFactory);

        try {
            // 4. 由上下文子类实现的方法，对bean工厂的后置处理
            // 这个时候所有bean定义都已加载，但还没有实例化bean。这允许在特定的ApplicationContext实现中注册特殊的BeanPostProcessors
            postProcessBeanFactory(beanFactory);

            // ☆☆☆5. 调用上下文中注册为bean的工厂处理器。
            // 实例化并调用所有已注册的BeanFactoryPostProcessor bean，必须在单例（singleton）实例化之前调用。
            // 实际上是由工具类PostProcessorRegistrationDelegate负责调用执行的。
            // ***BeanFactoryPostProcessor，是针对整个工厂生产出来的BeanDefinition作出修改或者注册。作用于BeanDefinition时期。
            invokeBeanFactoryPostProcessors(beanFactory);

            // ☆☆☆6. 注册拦截bean创建的bean处理器。
            // 实例化并注册所有BeanPostProcessor bean，如果给定，则遵循显式顺序。必须在任何应用程序bean的实例化之前调用。
            // 实际上是由工具类PostProcessorRegistrationDelegate负责调用执行的。
            // ***BeanPostProcessor 在bean实例化、初始化前后执行
            registerBeanPostProcessors(beanFactory);

            // 7. 为上下文初始化消息源。
            // MessageSource干嘛用的：比如国际化
            initMessageSource();

            // ☆☆☆8. 为上下文初始化事件广播程序。初始化ApplicationEventMulticaster。如果上下文中没有定义，则使用SimpleApplicationEventMulticaster。
            initApplicationEventMulticaster();

            // 9. 由上下文的子类实现的方法，初始化其它特殊Bean
            // 模板方法，可以覆盖该方法以添加特定于上下文的刷新工作。在单例（singleton）实例化之前，在初始化特殊bean时调用。
            onRefresh();

            // ☆☆☆10. 检查监听器bean并注册它们。
            // 添加的是ApplicationListener的实现类。发布事件的是ApplicationEventMulticaster，接收事件的是ApplicationListener。
            registerListeners();

            // ☆☆☆11. 实例化所有剩余的(非懒加载)单例。
            finishBeanFactoryInitialization(beanFactory);

            // ☆☆☆12. 最后一步:发布相应的事件。
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // ☆☆☆13. 销毁已经创建的单例，以避免挂起资源。
            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. 为上下文刷新做准备：设置其启动开始时间和活动标志以及执行任何属性源的初始化。初始化earlyApplicationListeners和earlyApplicationEvents。

2. 告诉子类刷新内部bean工厂。返回这个上下文所持有的内部BeanFactory。

3. 准备bean工厂以供在此上下文中使用。配置工厂的标准上下文特征，比如上下文的类加载器、后置处理器。

4. 由上下文子类实现的方法，对bean工厂的后置处理。

5. 调用上下文中注册为bean的工厂处理器（BeanFactoryPostProcessor）。

6. 注册拦截bean创建的bean处理器。（BeanPostProcessor）

7. 为上下文初始化消息源。

8. 为上下文初始化事件广播程序。初始化ApplicationEventMulticaster。如果上下文中没有定义，则使用SimpleApplicationEventMulticaster。

9. 由上下文的子类实现的方法，初始化其它特殊Bean。

10. 检查监听器bean并注册它们。和第8步协作。

11. 实例化所有剩余的(非懒加载)单例。

12. 最后一步:发布相应的事件。

如果发生异常----->

13. 销毁已经创建的单例，以避免挂起资源。

下面步骤拆分

0. 刷新过程有几个地方是由子类实现的，这里先做个例子

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * Created by 小LUA on 2020-02-24 10:27.
 */
public class MyApp extends AnnotationConfigApplicationContext {
    public MyApp(Class<?>... componentClasses) {
        super(componentClasses);
    }

    @Override
    protected void initPropertySources() {
        super.initPropertySources();
        System.out.println("子类实现，初始化其它属性源...");
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        System.out.println("子类实现对bean工厂的后置处理...");
    }

    @Override
    protected void onRefresh() throws BeansException {
        super.onRefresh();
        System.out.println("子类实现初始化其他特殊Bean...");
    }

    public static void main(String[] args){
        ApplicationContext context = new MyApp(SimpleConfig.class);
//        ApplicationContext context = new AnnotationConfigApplicationContext(SimpleConfig.class);
    }
}

输出

1. 为上下文刷新做准备

protected void prepareRefresh() {
    // 启动开始时间
    this.startupDate = System.currentTimeMillis();
    // 设置活动开关
    this.closed.set(false);
    this.active.set(true);
    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }
    // 在上下文环境中初始化任何占位符属性源。这里是由子类实现的。
    initPropertySources();
    // 验证所有标记为需要的属性都是可解析的
    getEnvironment().validateRequiredProperties();
    // 存储预刷新的 ApplicationListeners
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // 将本地应用程序监听器重置为预刷新状态。
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }
    // 初始化早期事件容器。收集早期的应用程序事件，一旦广播者 multicaster 可用，这里存储的事件将被发布
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

这里可以理解为：飞机起飞之前肯定要先启动（prepareRefresh），这个时候肯定要先看一下基础功能是否正常。

> 启动时间

> 系统状态更新为已激活

> 执行附加的操作（子类实现）

> 事件广播者和收听者准备就绪

2. 告诉子类刷新内部bean工厂。返回这个上下文所持有的内部BeanFactory。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 设置refreshed标志位为true
    refreshBeanFactory();
    // 返回内部BeanFactory
    return getBeanFactory();
}
protected final void refreshBeanFactory() throws IllegalStateException {
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
                "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
    }
    this.beanFactory.setSerializationId(getId());
}
public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}

这一步只做了两件事，可以理解为：飞机已经决定起飞（refreshed）了

> 设置refreshed标志位为true

> 返回内部BeanFactory

3. ☆☆☆准备bean工厂以供在此上下文中使用。配置工厂的标准上下文特征，比如上下文的类加载器、后置处理器等

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 告诉内部BeanFactory使用上下文的类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置Bean表达式解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 配置上下文回调
    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接口不被注册为可解析的类型
    // 消息源注册为Bean
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 将用于检测内部bean的早期后处理器注册为Applicationlistener。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    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()));
    }

    // 注册默认的环境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());
    }
}

这一步初始化了BeanFactory必须的一些工具。可以理解为：控制飞机的正常运行，需要多个子系统的协作，这里加载必须的子系统。

> 配置类加载器

> 配置后置处理器

> ...

4. 由上下文子类实现的方法，对bean工厂的后置处理

这个时候所有bean定义都已加载，但还没有实例化bean。这允许在特定的ApplicationContext实现中注册特殊的BeanPostProcessors

这一步的体现见上面第0步

5.☆☆☆调用上下文中注册为bean的工厂后置处理器。

// 允许自定义修改应用程序上下文的bean定义，调整上下文的底层bean工厂的bean属性值。
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // 先执行 BeanDefinitionRegistryPostProcessors 
    Set<String> processedBeans = new HashSet<>();

    // 如果是BeanDefinitionRegistry接口的实现
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 遍历执行Bean定义注册的后置处理器
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

        // 第一：不要在这里初始化FactoryBean：我们需要保证所有常规bean未初始化，以便让bean factory后置处理器应用于它们!
        // 第二：将实现PriorityOrdered, Ordered和其他操作的BeanDefinitionRegistryPostProcessors分开。
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 先执行实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
        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();

        // 然后执行实现Ordered接口的BeanDefinitionRegistryPostProcessors
        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();

        // 最后执行所有剩下的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();
        }

        // 最最后，调用到目前为止处理的所有处理器的postProcessBeanFactory回调。
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // 不是BeanDefinitionRegistry接口的实现，执行用上下文实例注册的工厂处理器（这个方法就是一个遍历执行的过程）
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 不要在这里初始化FactoryBean：我们需要保证所有常规bean未初始化，以便让bean factory后置处理器应用于它们!
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 将实现PriorityOrdered, Ordered和其他操作的BeanFactoryPostProcessors分开。
    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);
        }
    }

    // 先执行实现PriorityOrdered接口的BeanFactoryPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 然后执行实现Ordered接口的BeanFactoryPostProcessors
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后执行所有剩下的BeanFactoryPostProcessors
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清除缓存的合并bean定义，因为后处理器可能修改了原始的元数据
    beanFactory.clearMetadataCache();
}

看起来很多，但是主要分为两部分，而这两部分的逻辑是一样的。

⑴ 首先把后置处理器分为BeanDefinitionRegistryPostProcessor（BeanDefinitionRegistry后置处理器）和BeanFactoryPostProcessor（BeanFactory后置处理器）。

　　①将实现PriorityOrdered, Ordered和其他操作的后置处理器分开。

　　②先执行实现PriorityOrdered接口的XXXPostProcessor

　　③然后执行实现Ordered接口的XXXPostProcessor

　　④最后执行所有剩下的XXXPostProcessor

⑵ 清除缓存的合并bean定义，因为后处理器可能修改了原始的元数据

6. ☆☆☆注册拦截bean创建的bean处理器。

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 注册BeanPostProcessorChecker，它在BeanPostProcessor实例化期间创建bean时记录日志
    // 例如，当一个bean不能被所有的BeanPostProcessor处理时。
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // 将实现PriorityOrdered, Ordered和其他操作的BeanPostProcessors分开。
    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);
        }
    }

    // 先注册实现PriorityOrdered接口的BeanPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 然后注册实现Ordered接口的BeanPostProcessors
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    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);

    // 最后注册所有剩下的BeanPostProcessors.
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 最后，重新注册所有的内部BeanPostProcessors.
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // 将后处理器重新注册为ApplicationListener用于检测内部bean，将其移动到处理链的末端(用于获取代理等)。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

这部分的套路和执行BeanFactory后置处理器的过程是一样的。

⑴ 注册Bean后置处理器

　　① 将实现PriorityOrdered, Ordered和其他操作的BeanPostProcessors分开。

　　②先注册实现PriorityOrdered接口的BeanPostProcessors

　　③然后注册实现Ordered接口的BeanPostProcessors

　　④最后注册所有剩下的BeanPostProcessors.

⑵重新注册所有的内部BeanPostProcessors.

⑶将后处理器重新注册为ApplicationListener用于检测内部bean，将其移动到处理链的末端(用于获取代理等)。

7. 为上下文初始化消息源。

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 如果本地存在messageSource的Bean
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        // 就给属性赋值
        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());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        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 + "]");
        }
    }
}

8. ☆☆☆为上下文初始化事件广播程序。初始化ApplicationEventMulticaster。如果上下文中没有定义，则使用SimpleApplicationEventMulticaster。

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 如果本地存在applicationEventMulticaster的Bean
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 给applicationEventMulticaster属性赋值
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 否则初始化一个SimpleApplicationEventMulticaster，然后注册即可
        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. 由上下文的子类实现的方法，初始化其它特殊Bean

模板方法，可以覆盖该方法以添加特定于上下文的刷新工作。在单例（singleton）实例化之前，在初始化特殊bean时调用。

这一步的体现见上面第0步

10. ☆☆☆检查监听器bean并注册它们。

protected void registerListeners() {
    // 首先注册静态指定的监听器。
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 不要在这里初始化factorybean:我们需要保证所有常规bean未初始化，以便让后处理器应用于它们!
    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);
        }
    }
}

这里完成了两个事情：

> 注册应用程序监听器

> 发布早期事件（观察者模式的经典体现）

11. ☆☆☆实例化所有剩余的(非懒加载)单例。

 完成上下文bean工厂的初始化，初始化所有剩余的单例bean。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 为此上下文初始化转换服务（ConversionService）。
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 注册一个默认的嵌入式值解析器（主要用于解析注释属性值），如果之前没有注册任何bean后置处理器
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 尽早初始化LoadTimeWeaverAware bean，以便尽早注册它们的转换器。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 停止使用临时类加载器进行类型匹配。
    beanFactory.setTempClassLoader(null);

    // 允许缓存所有的bean定义元数据，不期望有进一步的更改。
    beanFactory.freezeConfiguration();

    // 实例化所有剩余的(非懒加载)单例。
    beanFactory.preInstantiateSingletons();
}

这一步干的工作比较多：

> 为上下文初始化转换服务

> 注册一个默认的嵌入式值解析器（主要用于解析注释属性值）

> 停止使用临时类加载器进行类型匹配。

> 允许缓存所有的bean定义元数据，不期望有进一步的更改。

> 实例化所有剩余的(非懒加载)单例。

关于preInstantiateSingletons的执行过程，实际上就是getBean的过程了，这部分上一篇文章做了解读。

12. ☆☆☆最后一步:发布相应的事件。

protected void finishRefresh() {
    // 清除上下文级别的资源缓存(比如扫描的ASM元数据)。
    clearResourceCaches();
    // 为此上下文初始化生命周期处理器。
    initLifecycleProcessor();
    // 将生命周期处理器的running标志位设置为true
    getLifecycleProcessor().onRefresh();
    // 发布最终事件。
    publishEvent(new ContextRefreshedEvent(this));
    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}

// 看一下ContextRefreshedEvent
public void publishEvent(ApplicationEvent event) {
    publishEvent(event, null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");
    // 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 {
        // 获取事件广播者，异步广播事件给对应的Listener
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }
    // 通过父上下文发布事件
    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));
    Executor executor = getTaskExecutor();
    // 遍历应用程序监听器
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        // 如果指定了executor，就走异步处理
        if (executor != null) {
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
            invokeListener(listener, event);
        }
    }
}

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            // 执行Listener，准确来说是监听器的【收听】方法
            doInvokeListener(listener, event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        doInvokeListener(listener, event);
    }
}

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
    try {
        // 这里调用ApplicationListener接口唯一的方法，也就是说，当接收到了事件，监听器要如何做的方法
        listener.onApplicationEvent(event);
    }
    catch (ClassCastException ex) {
        String msg = ex.getMessage();
        if (msg == null || matchesClassCastMessage(msg, event.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());
            if (logger.isTraceEnabled()) {
                logger.trace("Non-matching event type for listener: " + listener, ex);
            }
        }
        else {
            throw ex;
        }
    }
}

这里仅仅扩展一下，看下Spring如何利用【观察者模式】的。

----------------------------------------

这一步显而易见，善后处理：

> 清除上下文级别的资源缓存

> 为此上下文初始化生命周期处理器

> 发布最终事件（上下文已刷新事件）

13. ☆☆☆销毁已经创建的单例，以避免挂起资源。（异常情况）

// 如果你看了我上一篇文章，你会知道这段代码以及逻辑在哪里。这里不再赘述
protected void destroyBeans() {
    getBeanFactory().destroySingletons();
}

总结

宏观想一想，Spring启动的目的是什么？不就是要加载Bean嘛！

简单来讲：
1. 把配置解析成规范的Bean定义
2. 把Bean定义处理并生成Bean实例

而为了健壮性和扩展性：
refresh之前：初始化BeanDefinitionReader（Bean定义解析器）
refresh：
　　1. 为上下文刷新做准备：设置其启动开始时间和活动标志以及执行任何属性源的初始化。初始化earlyApplicationListeners和earlyApplicationEvents。
　　2. 刷新BeanFactory子容器，返回这个上下文所持有的内部BeanFactory。
　　3. 准备bean工厂以供在此上下文中使用。配置工厂的标准上下文特征，比如上下文的类加载器、后置处理器、注册要忽略的依赖接口、注册可解析的依赖。
　　4. 【扩展性】由上下文子类实现的方法，对bean工厂的后置处理。（这个时候所有bean定义都已加载，但还没有实例化bean。这允许在特定的ApplicationContext实现中注册特殊的BeanPostProcessors）
　　5. 调用已注册的BeanFactoryPostProcessor。针对整个工厂生产出来的BeanDefinition作出修改或者注册。作用于BeanDefinition时期。
　　6. 注册BeanPostProcessor。作用于bean，在bean实例化、初始化前后执行。
　　7. 初始化事件广播程序。
　　8. 【扩展性】模板方法，可以覆盖该方法以添加特定于上下文的刷新工作。在单例（singleton）实例化之前，在初始化特殊bean时调用。
　　9. 注册事件监听器。
　　10. 实例化所有剩余的单例Bean。
　　11. 发布刷新完成事件。（可以联想到Dubbo服务暴露的入口）
　　12. 如果以上步骤出现了异常，则要销毁已经创建的单例，以避免挂起资源。

而Bean的创建呢？

简单来讲：

1. 读取Bean定义信息

2. 根据定义来实例化

而为了严谨，多加了一些考虑

1. 确定Bean的原始名称，如果含有&则要去掉。

2. 先检查单例缓存是否存在。这部分涉及了几个缓存，比如：singletonObjects 和 earlySingletonObjects ，一个存放初始化完毕的Bean，一个存放已经实例化但是还未初始化的Bean，可以用来检测循环依赖。

3. 从缓存获取的可能是Bean，也可能是FactoryBean。所以这一步根据name特点来判断，如果是个FactoryBean，则调用其getObject方法来返回真正的Bean实例。

4. 执行创建Bean的逻辑

　　【扩展性】执行实例化Bean之前的后置处理器（InstantiationAwareBeanPostProcessor）

　　- 选取合适的策略来决定如何创建Bean

　　- 利用反射实例化后放入BeanWrapper包装类里并返回

　　【扩展性】执行实例化Bean之后的后置处理器（InstantiationAwareBeanPostProcessor）

　　- 根据自动装配模式来判断按照名称还是类型自动装配，具体为：将属性名-属性值映射关系装填到PropertyValues对象来供下面操作使用。

　　- 对PropertyValues进行后置处理、检查依赖

　　- 给Bean属性赋值

　　- 如果Bean实现了Aware接口，则先执行Aware相关方法

　　【扩展性】执行初始化Bean之前的后置处理器（BeanPostProcessor）

　　- 如果实现了 isInitializingBean 接口，则执行其中的 afterPropertiesSet 方法

　　- 如果指定了Bean的 initMethod 方法，则执行其初始化方法

　　【扩展性】执行初始化Bean之后的后置处理器（BeanPostProcessor）