在《几种自定义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
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 后置处理器。
这个方法会将所有单例、非懒加载对象进行实例化。
主要流程：
- ==初始化 Bean==
- 回调SmartInitializingSingleton.afterSingletonsInstantiated()
至此，容器中的 Bean 都已经创建好了，再来看下上面标黄的==初始化 Bean==的流程，《几种自定义Spring生命周期的初始化和销毁方法》中描述的一些过程都是在这个里面执行的。
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 进行最终的初始化工作