SpringBoot 這 16 個有用的擴展接口

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 還沒被類加載器加載的時機，進行動態字節碼注入等操作。

擴展方式爲：

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

擴展方式爲:

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的元信息。

擴展方式爲：

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 進行統一的設值等等。

擴展方式爲：

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 實例化的後置處理。這個方法就是在提前暴露的回調方法中觸發。

擴展方式爲：

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拿到進行緩存，日後使用。

擴展方式爲：

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 的值。

擴展方式爲：

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之前。

使用場景：用戶可以對某一方法進行標註，來進行初始化某一個屬性

擴展方式爲：

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之前。

使用場景：用戶實現此接口，來進行系統啓動的時候一些業務指標的初始化工作。

擴展方式爲：

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開始支持泛型，即接口聲明改爲FactoryBean<T>的形式

使用場景：用戶可以擴展這個類，來爲要實例化的 bean 作一個代理，比如爲該對象的所有的方法作一個攔截，在調用前後輸出一行 log，模仿ProxyFactoryBean的功能。

擴展方式爲：

public class TestFactoryBean implements FactoryBean<TestFactoryBean.TestFactoryInnerBean> {      
      
    @Override      
    public TestFactoryBean.TestFactoryInnerBean getObject() throws Exception {      
        System.out.println("[FactoryBean] getObject");      
        return new TestFactoryBean.TestFactoryInnerBean();      
    }      
      
    @Override      
    public Class<?> getObjectType() {      
        return TestFactoryBean.TestFactoryInnerBean.class;      
    }      
      
    @Override      
    public boolean isSingleton() {      
        return true;      
    }      
      
    public static class TestFactoryInnerBean{      
      
    }      
}

14.SmartInitializingSingleton

org.springframework.beans.factory.SmartInitializingSingleton

這個接口中只有一個方法afterSingletonsInstantiated，其作用是是在 spring 容器管理的所有單例對象（非懶加載對象）初始化完成之後調用的回調接口。其觸發時機爲postProcessAfterInitialization之後。

使用場景：用戶可以擴展此接口在對所有單例對象初始化完畢後，做一些後置的業務處理。

擴展方式爲：

public class TestSmartInitializingSingleton implements SmartInitializingSingleton {      
    @Override      
    public void afterSingletonsInstantiated() {      
        System.out.println("[TestSmartInitializingSingleton]");      
    }      
}

15.CommandLineRunner

org.springframework.boot.CommandLineRunner

這個接口也只有一個方法：run(String... args)，觸發時機爲整個項目啓動完畢後，自動執行。如果有多個CommandLineRunner，可以利用@Order來進行排序。

使用場景：用戶擴展此接口，進行啓動項目之後一些業務的預處理。

擴展方式爲：

public class TestCommandLineRunner implements CommandLineRunner {      
      
    @Override      
    public void run(String... args) throws Exception {      
        System.out.println("[TestCommandLineRunner]");      
    }      
}

16.DisposableBean

org.springframework.beans.factory.DisposableBean

這個擴展點也只有一個方法：destroy()，其觸發時機爲當此對象銷燬時，會自動執行這個方法。比如說運行applicationContext.registerShutdownHook時，就會觸發這個方法。

擴展方式爲：

public class NormalBeanA implements DisposableBean {      
    @Override      
    public void destroy() throws Exception {      
        System.out.println("[DisposableBean] NormalBeanA");      
    }      
}

17.ApplicationListener

org.springframework.context.ApplicationListener

準確的說，這個應該不算spring&springboot當中的一個擴展點，ApplicationListener可以監聽某個事件的event，觸發時機可以穿插在業務方法執行過程中，用戶可以自定義某個業務事件。

但是 spring 內部也有一些內置事件，這種事件，可以穿插在啓動調用中。我們也可以利用這個特性，來自己做一些內置事件的監聽器來達到和前面一些觸發點大致相同的事情。

接下來羅列下 spring 主要的內置事件：

ContextRefreshedEvent

ApplicationContext 被初始化或刷新時，該事件被髮布。這也可以在ConfigurableApplicationContext接口中使用 refresh()方法來發生。此處的初始化是指：所有的 Bean 被成功裝載，後處理 Bean 被檢測並激活，所有 Singleton Bean 被預實例化，ApplicationContext容器已就緒可用。
ContextStartedEvent

當使用 ConfigurableApplicationContext （ApplicationContext 子接口）接口中的 start() 方法啓動 ApplicationContext時，該事件被髮布。你可以調查你的數據庫，或者你可以在接受到這個事件後重啓任何停止的應用程序。
ContextStoppedEvent

當使用 ConfigurableApplicationContext接口中的 stop()停止ApplicationContext 時，發佈這個事件。你可以在接受到這個事件後做必要的清理的工作
ContextClosedEvent

當使用 ConfigurableApplicationContext接口中的 close()方法關閉 ApplicationContext 時，該事件被髮布。一個已關閉的上下文到達生命週期末端；它不能被刷新或重啓
RequestHandledEvent

這是一個 web-specific 事件，告訴所有 bean HTTP 請求已經被服務。只能應用於使用 DispatcherServlet 的 Web 應用。在使用 Spring 作爲前端的 MVC 控制器時，當 Spring 處理用戶請求結束後，系統會自動觸發該事件

18. 最後

我們從這些spring&springboot的擴展點當中，大致可以窺視到整個 bean 的生命週期。在業務開發或者寫中間件業務的時候，可以合理利用 spring 提供給我們的擴展點，在 spring 啓動的各個階段內做一些事情。以達到自定義初始化的目的。此篇總結，如果有錯誤或者疏漏的地方，懇請指正。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/jl6_YtEpYb4uJR0sgUZ3EQ

1. 背景

2. 可擴展的接口啓動調用順序圖

3.ApplicationContextInitializer

4.BeanDefinitionRegistryPostProcessor

5.BeanFactoryPostProcessor

6.InstantiationAwareBeanPostProcessor

7.SmartInstantiationAwareBeanPostProcessor

8.BeanFactoryAware

9.ApplicationContextAwareProcessor

10.BeanNameAware

11.@PostConstruct

12.InitializingBean

13.FactoryBean

14.SmartInitializingSingleton

15.CommandLineRunner

16.DisposableBean

17.ApplicationListener

18. 最後

猜你喜歡