Springboot啟動擴充套件點超詳細總結，再也不怕面試官問了
阿新 • • 發佈：2020-07-20
## 1.背景
Spring的核心思想就是容器，當容器refresh的時候，外部看上去風平浪靜，其實內部則是一片驚濤駭浪，汪洋一片。Springboot更是封裝了Spring，遵循約定大於配置，加上自動裝配的機制。很多時候我們只要引用了一個依賴，幾乎是零配置就能完成一個功能的裝配。
我非常喜歡這種自動裝配的機制，所以在自己開發中間件和公共依賴工具的時候也會用到這個特性。讓使用者以最小的代價接入。想要把自動裝配玩的轉，就必須要了解spring對於bean的構造生命週期以及各個擴充套件介面。當然瞭解了bean的各個生命週期也能促進我們加深對spring的理解。業務程式碼也能合理利用這些擴充套件點寫出更加漂亮的程式碼。
在網上搜索spring擴充套件點，發現很少有博文說的很全的，只有一些常用的擴充套件點的說明。
所以在這篇文章裡，我總結了幾乎Spring & Springboot所有的擴充套件介面，以及各個擴充套件點的使用場景。並且整理出了一個bean在spring內部從被載入到最後初始化完成所有可擴充套件點的順序呼叫圖。從而我們也能窺探到bean是如何一步步載入到spring容器中的。
## 2.可擴充套件的介面啟動呼叫順序圖
以下是我整理的spring容器中Bean的生命週期內所有可擴充套件的點的呼叫順序，下面會一個個分析
## 3.ApplicationContextInitializer
> org.springframework.context.ApplicationContextInitializer
這是整個spring容器在重新整理之前初始化`ConfigurableApplicationContext`的回撥介面，簡單來說，就是在容器重新整理之前呼叫此類的`initialize`方法。這個點允許被使用者自己擴充套件。使用者可以在整個spring容器還沒被初始化之前做一些事情。
可以想到的場景可能為，在最開始啟用一些配置，或者利用這時候class還沒被類載入器載入的時機，進行動態位元組碼注入等操作。
擴充套件方式為：
```java
public class TestApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("[ApplicationContextInitializer]");
}
}
```
因為這時候spring容器還沒被初始化，所以想要自己的擴充套件的生效，有以下三種方式：
* 在啟動類中用`springApplication.addInitializers(new TestApplicationContextInitializer())`語句加入
* 配置檔案配置`context.initializer.classes=com.example.demo.TestApplicationContextInitializer`
* Spring SPI擴充套件，在spring.factories中加入`org.springframework.context.ApplicationContextInitializer=com.example.demo.TestApplicationContextInitializer`
## 4.BeanDefinitionRegistryPostProcessor
> org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor
這個介面在讀取專案中的`beanDefinition`之後執行，提供一個補充的擴充套件點
使用場景：你可以在這裡動態註冊自己的`beanDefinition`，可以載入classpath之外的bean
擴充套件方式為:
```java
public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanDefinitionRegistry");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanFactory");
}
}
```
## 5.BeanFactoryPostProcessor
> org.springframework.beans.factory.config.BeanFactoryPostProcessor
這個介面是`beanFactory`的擴充套件介面，呼叫時機在spring在讀取`beanDefinition`資訊之後，例項化bean之前。
在這個時機，使用者可以通過實現這個擴充套件介面來自行處理一些東西，比如修改已經註冊的`beanDefinition`的元資訊。
擴充套件方式為：
```java
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("[BeanFactoryPostProcessor]");
}
}
```
## 6.InstantiationAwareBeanPostProcessor
> org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor
該介面繼承了`BeanPostProcess`介面，區別如下：
**`BeanPostProcess`介面只在bean的初始化階段進行擴充套件（注入spring上下文前後），而`InstantiationAwareBeanPostProcessor`介面在此基礎上增加了3個方法，把可擴充套件的範圍增加了例項化階段和屬性注入階段。**
該類主要的擴充套件點有以下5個方法，主要在bean生命週期的兩大階段：**例項化階段**和**初始化階段**，下面一起進行說明，按呼叫順序為：
* `postProcessBeforeInstantiation`：例項化bean之前，相當於new這個bean之前
* `postProcessAfterInstantiation`：例項化bean之後，相當於new這個bean之後
* `postProcessPropertyValues`：bean已經例項化完成，在屬性注入時階段觸發，`@Autowired`,`@Resource`等註解原理基於此方法實現
* `postProcessBeforeInitialization`：初始化bean之前，相當於把bean注入spring上下文之前
* `postProcessAfterInitialization`：初始化bean之後，相當於把bean注入spring上下文之後
使用場景：這個擴充套件點非常有用 ，無論是寫中介軟體和業務中，都能利用這個特性。比如對實現了某一類介面的bean在各個生命期間進行收集，或者對某個型別的bean進行統一的設值等等。
擴充套件方式為：
```java
public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization " + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization " + beanName);
return bean;
}
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation " + beanName);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation " + beanName);
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessPropertyValues " + beanName);
return pvs;
}
```
## 7.SmartInstantiationAwareBeanPostProcessor
> org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor
該擴充套件介面有3個觸發點方法：
* `predictBeanType`：該觸發點發生在`postProcessBeforeInstantiation`之前(在圖上並沒有標明，因為一般不太需要擴充套件這個點)，這個方法用於預測Bean的型別，返回第一個預測成功的Class型別，如果不能預測返回null；當你呼叫`BeanFactory.getType(name)`時當通過bean的名字無法得到bean型別資訊時就呼叫該回調方法來決定型別資訊。
* `determineCandidateConstructors`：該觸發點發生在`postProcessBeforeInstantiation`之後，用於確定該bean的建構函式之用，返回的是該bean的所有建構函式列表。使用者可以擴充套件這個點，來自定義選擇相應的構造器來例項化這個bean。
* `getEarlyBeanReference`：該觸發點發生在`postProcessAfterInstantiation`之後，當有迴圈依賴的場景，當bean例項化好之後，為了防止有迴圈依賴，會提前暴露回撥方法，用於bean例項化的後置處理。這個方法就是在提前暴露的回撥方法中觸發。
擴充套件方式為：
```java
public class TestSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
@Override
public Class predictBeanType(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] predictBeanType " + beanName);
return beanClass;
}
@Override
public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] determineCandidateConstructors " + beanName);
return null;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] getEarlyBeanReference " + beanName);
return bean;
}
}
```
## 8.BeanFactoryAware
> org.springframework.beans.factory.BeanFactoryAware
這個類只有一個觸發點，發生在bean的例項化之後，注入屬性之前，也就是Setter之前。這個類的擴充套件點方法為`setBeanFactory`，可以拿到`BeanFactory`這個屬性。
使用場景為，你可以在bean例項化之後，但還未初始化之前，拿到 `BeanFactory`，在這個時候，可以對每個bean作特殊化的定製。也或者可以把`BeanFactory`拿到進行快取，日後使用。
擴充套件方式為：
```java
public class TestBeanFactoryAware implements BeanFactoryAware {
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("[TestBeanFactoryAware] " + beanFactory.getBean(TestBeanFactoryAware.class).getClass().getSimpleName());
}
}
```
## 9.ApplicationContextAwareProcessor
> org.springframework.context.support.ApplicationContextAwareProcessor
該類本身並沒有擴充套件點，但是該類內部卻有6個擴充套件點可供實現 ，這些類觸發的時機在bean例項化之後，初始化之前
可以看到，該類用於執行各種驅動介面，在bean例項化之後，屬性填充之後，通過執行以上紅框標出的擴充套件介面，來獲取對應容器的變數。**所以這裡應該來說是有6個擴充套件點**，這裡就放一起來說了
* `EnvironmentAware`：用於獲取`EnviromentAware`的一個擴充套件類，這個變數非常有用， 可以獲得系統內的所有引數。當然個人認為這個Aware沒必要去擴充套件，因為spring內部都可以通過注入的方式來直接獲得。
* `EmbeddedValueResolverAware`：用於獲取`StringValueResolver`的一個擴充套件類， `StringValueResolver`用於獲取基於`String`型別的properties的變數，一般我們都用`@Value`的方式去獲取，如果實現了這個Aware介面，把`StringValueResolver`快取起來，通過這個類去獲取`String`型別的變數，效果是一樣的。
* `ResourceLoaderAware`：用於獲取`ResourceLoader`的一個擴充套件類，`ResourceLoader`可以用於獲取classpath內所有的資源物件，可以擴充套件此類來拿到`ResourceLoader`物件。
* `ApplicationEventPublisherAware`：用於獲取`ApplicationEventPublisher`的一個擴充套件類，`ApplicationEventPublisher`可以用來發布事件，結合`ApplicationListener`來共同使用，下文在介紹`ApplicationListener`時會詳細提到。這個物件也可以通過spring注入的方式來獲得。
* `MessageSourceAware`：用於獲取`MessageSource`的一個擴充套件類，`MessageSource`主要用來做國際化。
* `ApplicationContextAware`：用來獲取`ApplicationContext`的一個擴充套件類，`ApplicationContext`應該是很多人非常熟悉的一個類了，就是spring上下文管理器，可以手動的獲取任何在spring上下文註冊的bean，我們經常擴充套件這個介面來快取spring上下文，包裝成靜態方法。同時`ApplicationContext`也實現了`BeanFactory`，`MessageSource`，`ApplicationEventPublisher`等介面，也可以用來做相關介面的事情。
## 10.BeanNameAware
> org.springframework.beans.factory.BeanNameAware
可以看到，這個類也是Aware擴充套件的一種，觸發點在bean的初始化之前，也就是`postProcessBeforeInitialization`之前，這個類的觸發點方法只有一個：`setBeanName`
使用場景為：使用者可以擴充套件這個點，在初始化bean之前拿到spring容器中註冊的的beanName，來自行修改這個beanName的值。
擴充套件方式為：
```java
public class NormalBeanA implements BeanNameAware{
public NormalBeanA() {
System.out.println("NormalBean constructor");
}
@Override
public void setBeanName(String name) {
System.out.println("[BeanNameAware] " + name);
}
}
```
## 11.@PostConstruct
> javax.annotation.PostConstruct
這個並不算一個擴充套件點，其實就是一個標註。其作用是在bean的初始化階段，如果對一個方法標註了`@PostConstruct`，會先呼叫這個方法。這裡重點是要關注下這個標準的觸發點，這個觸發點是在`postProcessBeforeInitialization`之後，`InitializingBean.afterPropertiesSet`之前。
使用場景：使用者可以對某一方法進行標註，來進行初始化某一個屬性
擴充套件方式為：
```java
public class NormalBeanA {
public NormalBeanA() {
System.out.println("NormalBean constructor");
}
@PostConstruct
public void init(){
System.out.println("[PostConstruct] NormalBeanA");
}
}
```
## 12.InitializingBean
> org.springframework.beans.factory.InitializingBean
這個類，顧名思義，也是用來初始化bean的。`InitializingBean`介面為bean提供了初始化方法的方式，它只包括`afterPropertiesSet`方法，凡是繼承該介面的類，在初始化bean的時候都會執行該方法。這個擴充套件點的觸發時機在`postProcessAfterInitialization`之前。
使用場景：使用者實現此介面，來進行系統啟動的時候一些業務指標的初始化工作。
擴充套件方式為：
```java
public class NormalBeanA implements InitializingBean{
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("[InitializingBean] NormalBeanA");
}
}
```
## 13.FactoryBean
> org.springframework.beans.factory.FactoryBean
一般情況下，Spring通過反射機制利用bean的class屬性指定支線類去例項化bean，在某些情況下，例項化Bean過程比較複雜，如果按照傳統的方式，則需要在bean中提供大量的配置資訊。配置方式的靈活性是受限的，這時採用編碼的方式可能會得到一個簡單的方案。Spring為此提供了一個`org.springframework.bean.factory.FactoryBean`的工廠類介面，使用者可以通過實現該介面定製例項化Bean的邏輯。`FactoryBean`介面對於Spring框架來說佔用重要的地位，Spring自身就提供了70多個`FactoryBean`的實現。它們隱藏了例項化一些複雜bean的細節，給上層應用帶來了便利。從Spring3.0開始，`FactoryBean`開始支援泛型，即介面宣告改為`Fac