在《几种自定义Spring生命周期的初始化和销毁方法》最后一段描述了启动 Spring 容器过程中，初始化和销毁方法的执行时机，那么在 Spring 中是如何做到的呢？

注册主配置类

Spring 使用AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);指定主配置类，将其注册到 BeanFactory。除了主配置类，还会将一些基础的后置处理器类注册到 BeanFactory，如下所示：

• 初始化AnnotatedBeanDefinitionReader，内部后置处理器注册到BeanFactory

  • internalConfigurationAnnotationProcessor->ConfigurationClassPostProcessor
  • internalAutowiredAnnotationProcessor->AutowiredAnnotationBeanPostProcessor
  • internalCommonAnnotationProcessor->CommonAnnotationBeanPostProcessor
  • internalPersistenceAnnotationProcessor->PersistenceAnnotationBeanPostProcessor
  • internalEventListenerProcessor->EventListenerMethodProcessor
  • internalEventListenerFactory->DefaultEventListenerFactory
    

• 初始化ClassPathBeanDefinitionScanner，加载环境和资源配置

  • Environment
  • ResourceLoader
    

  
  

refresh()

Spring 中非常核心的源码 AbstractApplicationContext.refresh()，顾名思义，这是用来更新 Spring 应用上下文的方法，对 Spring 容器进行初始化、更新等操作。

// 部分源码public void refresh() {    // 取出注册的 BeanFactory    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();    // 配置 BeanFactory    prepareBeanFactory(beanFactory);    // 初始化执行 BeanFactory 后置处理器    invokeBeanFactoryPostProcessors(beanFactory);    // 注册 Bean 后置处理器    registerBeanPostProcessors(beanFactory);    // 执行 Bean 后置处理器    finishBeanFactoryInitialization(beanFactory);}1、初始化执行 BeanFactory 后置处理器整体顺序

---

首先会按照顺序执行 BeanDefinitionRegistryPostProcessor 的实现类

• 执行实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor。
• 执行实现了 Ordered 的 BeanDefinitionRegistryPostProcessor。
• 执行所有剩下的 BeanDefinitionRegistryPostProcessor。
  

上面的每一步都会先在容器中==初始化 Bean==，然后去执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry() 方法。因为 BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor，所以也会执行 postProcessBeanFactory() 方法。

---

然后按顺序执行 BeanFactoryPostProcessor 的实现类

• 执行实现了 PriorityOrdered 的 BeanFactoryPostProcessor。
• 执行实现了 Ordered 的 BeanFactoryPostProcessor。
• 执行所有剩下的 BeanFactoryPostProcessor。
  

上面的每一步都会先在容器中==初始化 Bean==，然后去执行 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法。

---

执行细节

以 ConfigurationClassPostProcessor 为例，这个类是 BeanDefinitionRegistryPostProcessor 的实现类，是 @Configuration 注解配置类的启动引导类，在注册主配置类时，已经注册到 BeanFactory，此外，此类还实现了 PriorityOrdered，从执行顺序可知，它会被优先执行。

1、ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry()

• 首先会找到主配置类，即标注 @Configuration 的类。
• 创建配置类解析器 ConfigurationClassParser ，以主配置类为入口，其方法 doProcessConfigurationClass() 会根据主配置类上标注的注解，按照下面的顺序依次找到所有的 Spring 组件。
  • @PropertySource 将配置数据加载到缓存
  • @ComponentScan 扫描类路径下的所有类，过滤出 @Component 注解类
  • @Import 加载 @Import 导入的类。如果该类是 ImportSelector，则会去执行其方法 selectImports()；如果是 ImportBeanDefinitionRegistrar，则只是将其加入缓存，还不会执行他的方法；否则，直接当作 @Configuration 注解类处理。
  • @ImportResource
  • @Bean 加载 @Bean 标注的方法。
  • 接口默认方法
  • 父类
    
• ConfigurationClassBeanDefinitionReader 遍历找到的所有组件，并将 @Import 导入的类注册到 BeanFactory。此时，会执行 ImportBeanDefinitionRegistrar.registerBeanDefinitions() 方法
  

2、ConfigurationClassPostProcessor.postProcessBeanFactory()

• 执行 BeanDefinitionRegistryPostProcessor 实现类的 postProcessBeanFactory()，利用CGLib增强配置类
• 注册后置处理器 ImportAwareBeanPostProcessor
  

3、ImportAwareBeanPostProcessor.postProcessBeanFactory()

• 回调ImportAware.setImportMetadata()
  

执行剩下的 BeanFactoryPostProcessor 实现类的 postProcessBeanFactory()

---

至此，BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 都已经执行完了， 但是一部分自定义的 Bean 还没开始初始化，需要执行 Bean 后置处理器。

2、执行 Bean 后置处理器

这个方法会将所有单例、非懒加载对象进行实例化。

主要流程：

• ==初始化 Bean==
• 回调SmartInitializingSingleton.afterSingletonsInstantiated()
  

至此，容器中的 Bean 都已经创建好了，再来看下上面标黄的==初始化 Bean==的流程，《几种自定义Spring生命周期的初始化和销毁方法》中描述的一些过程都是在这个里面执行的。

3、==初始化 Bean==

AbstractBeanFactory 是 BeanFactory 的抽象实现类，创建 Bean 的入口是 doGetBean()。首先，它会检查缓存中是否存在该 Bean，如果存在，则直接获取，并返回；如果缓存中不存在，再看是创建 Bean 的流程。

AbstractAutowireCapableBeanFactory 实现了 AbstractBeanFactory 创建 Bean 的方法 createBean()，Spring 会调用它的方法 doCreateBean() 来创建 Bean 实例。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {    // 1.反射执行构造器方法    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);        // 属性赋值    populateBean(beanName, mbd, instanceWrapper);    // 初始化 Bean    exposedObject = initializeBean(beanName, exposedObject, mbd);->4.afterPropertiesSet->5.invokeCustomInitMethod    return exposedObject;}

上述源码中 initializeBean() 方法中会顺序执行

• BeanPostProcessor.postProcessBeforeInitialization()
• @PostConstruct
• InitializingBean.afterPropertiesSet()
• initMethod()
• BeanPostProcessor.postProcessAfterInitialization()
  

主要源码和注释如下

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {    // 执行 Aware 接口实现方法    invokeAwareMethods(beanName, bean);    // 2.执行 BeanPostProcessor.postProcessBeforeInitialization()    // 3.上面的方法内部实际上回去执行 @PostConstruct 注解的方法    applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);    // 4.执行 InitializingBean.afterPropertiesSet()    // 5.然后执行自定义的 initMethod() 方法    invokeInitMethods(beanName, wrappedBean, mbd);        // 6.执行 BeanPostProcessor.postProcessAfterInitialization()    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);    return wrappedBean;}

注意，initializeBean() 方法中的 invokeAwareMethods() 会去执行部分 Aware 接口实现类的方法，见Spring Aware源码。

---

总结

• Spring 启动时，首先会将主配置类和基础的后置处理器类注册到 BeanFactory
• 调用 refresh() 方法，将上述 BeanFactory 中的后置处理器取出，并执行后置处理器的实现方法，扫描所有可用的 Bean 注册到 BeanFactory
• 将 BeanFactory 中所有可用的 Bean 进行最终的初始化工作
  

有任何问题欢迎在评论区留言

或者添加学姐微信
DKA-2018