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 進行最終的初始化工作