Springboot啓動擴展點超詳細總結，不再怕面試官問了

時間  2020-06-29
標籤 springboot 啓動 擴展 詳細 總結 不再 面試 欄目 Spring 简体版
原文   原文鏈接

1.背景

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

我很是喜歡這種自動裝配的機制，因此在本身開發中間件和公共依賴工具的時候也會用到這個特性。讓使用者以最小的代價接入。想要把自動裝配玩的轉，就必需要了解spring對於bean的構造生命週期以及各個擴展接口。固然瞭解了bean的各個生命週期也能促進咱們加深對spring的理解。業務代碼也能合理利用這些擴展點寫出更加漂亮的代碼。java

在網上搜索spring擴展點，發現不多有博文說的很全的，只有一些經常使用的擴展點的說明。web

因此在這篇文章裏，我總結了幾乎Spring & Springboot全部的擴展接口，以及各個擴展點的使用場景。而且整理出了一個bean在spring內部從被加載到最後初始化完成全部可擴展點的順序調用圖。從而咱們也能窺探到bean是如何一步步加載到spring容器中的。spring

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

如下是我整理的spring容器中Bean的生命週期內全部可擴展的點的調用順序，下面會一個個分析數據庫

1.jpg

3.ApplicationContextInitializer

org.springframework.context.ApplicationContextInitializer

這是整個spring容器在刷新以前初始化ConfigurableApplicationContext的回調接口，簡單來講，就是在容器刷新以前調用此類的initialize方法。這個點容許被用戶本身擴展。用戶能夠在整個spring容器還沒被初始化以前作一些事情。緩存

能夠想到的場景可能爲，在最開始激活一些配置，或者利用這時候class還沒被類加載器加載的時機，進行動態字節碼注入等操做。springboot

擴展方式爲：微信

public class TestApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("[ApplicationContextInitializer]");
    }
}

由於這時候spring容器還沒被初始化，因此想要本身的擴展的生效，有如下三種方式：app

  • 在啓動類中用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接口，區別以下：

<font color="red">BeanPostProcess接口只在bean的初始化階段進行擴展（注入spring上下文先後），而InstantiationAwareBeanPostProcessor接口在此基礎上增長了3個方法，把可擴展的範圍增長了實例化階段和屬性注入階段。</font>

該類主要的擴展點有如下5個方法，主要在bean生命週期的兩大階段：<font color=red>實例化階段</font>和<font color=red>初始化階段</font>，下面一塊兒進行說明，按調用順序爲：

  • 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實例化以後，初始化以前

2.png

能夠看到，該類用於執行各類驅動接口，在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啓動的各個階段內作一些事情。以達到自定義初始化的目的。此篇總結，若是有錯誤或者疏漏的地方，懇請指正。

下一篇，應某位小夥伴要求，準備總結下在springboot啓動過程當中，咱們如何控制bean的加載順序的各類辦法，讓bean的加載順序徹底受你掌控。

19.聯繫做者

微信關注獲取更多技術乾貨
offIical-wx.jpg

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程