Spring IOC容器初始化主流程

1. Spring IOC容器体系

IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决⽅案。 Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器 必须遵从的⼀套原则，具体的容器实现可以增加额外的功能，⽐如我们常⽤到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等⼀系列的内容，AnnotationConfigApplicationContext 则是包含了注解解析等⼀系列的内容。 Spring IoC 容器继承体系⾮常聪明，需要使⽤哪个层次⽤哪个层次即可，不必使⽤功能⼤⽽全的。
BeanFactory顶级接口的方法栈如下：

BeanFactory的继承和实现体系:

2. Bean生命周期关键时机点

1. Bean对象初始化：非延迟加载的Bean对象，在容器初始化过程中就创建完成了。
2. 分析构造函数调⽤情况：构造函数的调⽤时机在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory)处;
3. 分析 InitializingBean 之 afterPropertiesSet 初始化⽅法调⽤情况: InitializingBean中afterPropertiesSet ⽅法的调⽤时机也是在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory);
4. 分析BeanFactoryPostProcessor 初始化和调⽤情况：
   BeanFactoryPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的invokeBeanFactoryPostProcessors(beanFactory);
   postProcessBeanFactory 调⽤在AbstractApplicationContext类refresh⽅法的invokeBeanFactoryPostProcessors(beanFactory);
5. 分析 BeanPostProcessor 初始化和调⽤情况：
   BeanPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的 registerBeanPostProcessors(beanFactory);
   postProcessBeforeInitialization 调⽤在AbstractApplicationContext类refresh⽅法的 finishBeanFactoryInitialization(beanFactory);
   postProcessAfterInitialization 调⽤在AbstractApplicationContext类refresh⽅法的 finishBeanFactoryInitialization(beanFactory);
6. 总结：通过上述内容可以得出，Bean对象创建的⼏个关键时机点代码层级的调⽤都在AbstractApplicationContext 类 的 refresh ⽅法中，可⻅这个⽅法对于Spring IoC 容器初始化来说相当关键。

3. IOC容器初始主流程

由上面分析的内容，可以看出IOC容器的初始化主要是在AbstractApplicationContext类refresh⽅法中，下面分析一下refresh方法的流程内容：
第一步：刷新预处理

prepareRefresh();

第二步：创建BeanFactory: 默认实现的是ConfigurableListableBeanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

第三步：BeanFactory预备工作，比如Context的类加载

prepareBeanFactory(beanFactory);

第四步：BeanFactory准备⼯作完成后进⾏的后置处理⼯作

postProcessBeanFactory(beanFactory);

第五步：实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean

invokeBeanFactoryPostProcessors(beanFactory);

第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行

registerBeanPostProcessors(beanFactory);

第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

initMessageSource();

第八步：初始化事件派发器

initApplicationEventMulticaster();

第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑

onRefresh();

第十步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器Bean

registerListeners();

第十一步：初始化所有剩下的⾮懒加载的单例bean；初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）；填充属性；初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、 init-method⽅法）；调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处理

finishBeanFactoryInitialization(beanFactory);

第十二步：完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事件（ContextRefreshedEvent）

finishRefresh();

整体流程如下所示：

@Override
public void refresh() throws BeansException, IllegalStateException {
   //对象加锁
   synchronized (this.startupShutdownMonitor) {
      // 第一步：刷新前的预处理
      prepareRefresh();

      /**
       * 第二步:
       * 获取BeanFactory;默认实现是ConfigurableListableBeanFactory，
       * 加载BeanDefinition并注册到BeanDefinitionRegistry
          */
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      /**
       * 第三步:（BeanFactory进⾏⼀些设置，⽐如context的类加
       * 载器等）
       */
      prepareBeanFactory(beanFactory);

      try {
         /**
          * 第四步： BeanFactory准备⼯作完成后进⾏的后置处理⼯作
          */
         postProcessBeanFactory(beanFactory);

         /**
          * 第五步：实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
          */
         invokeBeanFactoryPostProcessors(beanFactory);

         /**
          * 第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执
          */
         registerBeanPostProcessors(beanFactory);

         /**
          * 第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
          */
         initMessageSource();

         /**
          * 第⼋步：初始化事件派发器
          */
         initApplicationEventMulticaster();

         /**
          * 第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
          */
         onRefresh();

         /**
          * 第⼗步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器
          * bean
          */
         registerListeners();

         /**
          * 第⼗⼀步：
          * 初始化所有剩下的⾮懒加载的单例bean
          * 初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
          * 填充属性
          * 初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、 init-method⽅法）
          * 调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
          */
         finishBeanFactoryInitialization(beanFactory);

         /**
          * 第⼗⼆步：
          * 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事
          * 件（ContextRefreshedEvent）
          */
         finishRefresh();
      }

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