Springboot啟動擴展點超詳細總結，再也不怕面試官問了-有解無憂

1.背景

Spring的核心思想就是容器，當容器refresh的時候，外部看上去風平浪靜，其實內部則是一片驚濤駭浪，汪洋一片，Springboot更是封裝了Spring，遵循約定大于配置，加上自動裝配的機制，很多時候我們只要參考了一個依賴，幾乎是零配置就能完成一個功能的裝配，

我非常喜歡這種自動裝配的機制，所以在自己開發中間件和公共依賴工具的時候也會用到這個特性，讓使用者以最小的代價接入，想要把自動裝配玩的轉，就必須要了解spring對于bean的構造生命周期以及各個擴展介面，當然了解了bean的各個生命周期也能促進我們加深對spring的理解，業務代碼也能合理利用這些擴展點寫出更加漂亮的代碼，

在網上搜索spring擴展點，發現很少有博文說的很全的，只有一些常用的擴展點的說明，

所以在這篇文章里，我總結了幾乎Spring & Springboot所有的擴展介面，以及各個擴展點的使用場景，并且整理出了一個bean在spring內部從被加載到最后初始化完成所有可擴展點的順序呼叫圖，從而我們也能窺探到bean是如何一步步加載到spring容器中的，

2.可擴展的介面啟動呼叫順序圖

以下是我整理的spring容器中Bean的生命周期內所有可擴展的點的呼叫順序，下面會一個個分析

file

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實體化之后，初始化之前

file

可以看到，該類用于執行各種驅動介面，在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啟動的各個階段內做一些事情，以達到自定義初始化的目的，此篇總結，如果有錯誤或者疏漏的地方，懇請指正，

聯系作者

微信關注「jishuyuanren」或者掃描以下二維碼獲取更多技術干貨：

file

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/139416.html

標籤：Java

上一篇：一文帶您讀懂什么是Spring Cloud與Spring Cloud Alibaba

下一篇：從原始碼角度來剖析ThreadLocal到底有沒有記憶體泄漏？