所有初始化流程到包含在 (org.springframework.context.support) AbstractApplicationContext#refresh() 中：

    1. @Override
    2. public void refresh() throws BeansException, IllegalStateException {
    3.     synchronized (this.startupShutdownMonitor) {
    4.         StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    6.         // Step 1: 刷新预处理，不管之前有没有容器，现在都会清除掉重置信息
    7.         // Prepare this context for refreshing.
    8.         prepareRefresh();
    10.         // Step 2: Spring 初始化 bean 工厂的流程
    11.         //      a) 创建 IoC 容器（DefaultListableBeanFactory）
    12.         //      b) 加载解析 XML 文件（最终存储到 Document 对象中）
    13.         //      c) 读取 Document 对象，并完成 BeanDefinition 的加载和注册工作
    14.         // Tell the subclass to refresh the internal bean factory.
    15.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    17.         // Step 3: 对 IoC 容器进行一些预处理（设置一些公共属性）
    18.         // Prepare the bean factory for use in this context.
    19.         prepareBeanFactory(beanFactory);
    21.         try {
    22.             // Step 4: 后置处理 bean 工厂，对 bean 工厂进行一些注册操作
    23.             // Allows post-processing of the bean factory in context subclasses.
    24.             postProcessBeanFactory(beanFactory);
    26.             StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
    28.             // Step 5: 调用 BeanFactoryPostProcessor 后置处理器对 BeanDefinition 处理，发生在 bean 创建之前
    29.             // Invoke factory processors registered as beans in the context.
    30.             invokeBeanFactoryPostProcessors(beanFactory);
    32.             // Step 6: 注册 BeanPostProcessor 后置处理器
    33.             // Register bean processors that intercept bean creation.
    34.             registerBeanPostProcessors(beanFactory);
    35.             beanPostProcess.end();
    37.             // Step 7: 初始化一些消息源（比如处理国际化的 i18n 等消息源）
    38.             // Initialize message source for this context.
    39.             initMessageSource();
    41.             // -------------------------------------- 基础容器中没有，只存在于高级容器中 -----------------------------------
    42.             // Step 8：初始化应用事件广播器
    43.             // Initialize event multicaster for this context.
    44.             initApplicationEventMulticaster();
    46.             // Step 9: 初始化一些特殊的 bean （内置 bean）
    47.             // Initialize other special beans in specific context subclasses.
    48.             onRefresh();
    50.             // Step 10：注册一些监听器
    51.             // Check for listener beans and register them.
    52.             registerListeners();
    54.             // -----------------------------------------------------------------------------------------------------
    56.             // Step 11: 实例化剩余的单例 bean（）非懒加载方式
    57.             // 注意事项：Bean 的 IoC、DI 和 AOP 都是发生在此步骤
    58.             // Instantiate all remaining (non-lazy-init) singletons.
    59.             finishBeanFactoryInitialization(beanFactory);
    61.             // Step 12: 完成刷新时，需要发布对外的事件
    62.             // Last step: publish corresponding event.
    63.             finishRefresh();
    64.         }
    66.         catch (BeansException ex) {
    67.             if (logger.isWarnEnabled()) {
    68.                 logger.warn("Exception encountered during context initialization - " +
    69.                             "cancelling refresh attempt: " + ex);
    70.             }
    72.             // Destroy already created singletons to avoid dangling resources.
    73.             destroyBeans();
    75.             // Reset 'active' flag.
    76.             cancelRefresh(ex);
    78.             // Propagate exception to caller.
    79.             throw ex;
    80.         }
    82.         finally {
    83.             // Reset common introspection caches in Spring's core, since we
    84.             // might not ever need metadata for singleton beans anymore...
    85.             resetCommonCaches();
    86.             contextRefresh.end();
    87.         }
    88.     }
    89. }

    总结下来，共有 12 步：

    • Step 1: 刷新预处理，不管之前有没有容器，现在都会清除掉重置信息
    • Step 2: Spring 初始化 bean 工厂的流程
    • Step 3: 对 IoC 容器进行一些预处理（设置一些公共属性）
    • Step 4: 后置处理 bean 工厂，对 bean 工厂进行一些注册操作
    • Step 5: 调用 BeanFactoryPostProcessor 后置处理器对 BeanDefinition 处理，发生在 bean 创建之前
    • Step 6: 注册 BeanPostProcessor 后置处理器
    • Step 7: 初始化一些消息源（比如处理国际化的 i18n 等消息源）
    • Step 8：初始化应用事件广播器
    • Step 9: 初始化一些特殊的 bean （内置 bean）
    • Step 10：注册一些监听器
    • Step 11: 实例化剩余的单例 bean（）非懒加载方式
    • Step 12: 完成刷新时，需要发布对外的事件