Spring 后置处理器源码

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

注册主配置类

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

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

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

2. 初始化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 的实现类

1. 执行实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor。
2. 执行实现了 Ordered 的 BeanDefinitionRegistryPostProcessor。
3. 执行所有剩下的 BeanDefinitionRegistryPostProcessor。

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

---

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

1. 执行实现了 PriorityOrdered 的 BeanFactoryPostProcessor。
2. 执行实现了 Ordered 的 BeanFactoryPostProcessor。
3. 执行所有剩下的 BeanFactoryPostProcessor。

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

---

执行细节

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

1、ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry()

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

2、ConfigurationClassPostProcessor.postProcessBeanFactory()

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

3、ImportAwareBeanPostProcessor.postProcessBeanFactory()

1. 回调ImportAware.setImportMetadata()

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

---

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

2、执行 Bean 后置处理器

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

主要流程：

1. 初始化 Bean
2. 回调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 进行最终的初始化工作