2. 程式人生 > >spring原始碼閱讀筆記10：bean生命週期

spring原始碼閱讀筆記10：bean生命週期

阿新 • • 發佈：2020-05-07

　　前面的文章主要集中在分析Spring IOC容器部分的原理，這部分的核心邏輯是和bean建立及管理相關，對於單例bean的管理，從建立好到快取起來再到銷燬，其是有一個完整的生命週期，並且Spring也在整個bean的建立過程中提供了多處介面供使用者自己擴充套件，本文就來梳理一下Spring中的bean生命週期。

1. Spring 容器中 Bean 的生命週期

　　對於prototype作用域的Bean，Spring容器僅僅負責建立，當容器建立了Bean例項之後，Bean例項完全交給客戶端程式碼管理，容器不再跟蹤其生命週期。每次客戶端請求prototype作用域的Bean時，Spring都會產生一個新的例項，Spring容器無法知道它曾經創造了多少個prototype作用域的Bean，也無從知道這些prototype作用域的Bean什麼時候才會銷燬。因此，Spring無法管理prototype作用域的Bean。

  對於singleton作用域的Bean，每次客戶端程式碼請求時，都返回同一個共享例項，客戶端程式碼不能控制Bean的銷燬，Spring容器負責跟蹤Bean例項的產生、銷燬。Spring容器可以在建立Bean之後，進行某些通用資源的申請；還可以在銷燬Bean例項之前，先回收某些資源，比如資料庫連線等。

  先來看一下Spring Bean的完整生命週期，從建立Spring容器開始，直到最終Spring容器銷燬Bean:

　　我們將Spring容器中Bean的生命週期級別分為四級，分別是：

  • Bean自身方法;
  • Bean級生命週期介面方法;
  • 容器級生命週期介面方法;
  • 工廠後處理器介面方法。

1.1 Bean自身方法

  Bean自身的方法：呼叫建構函式例項化bean，呼叫setter設定屬性，呼叫init-method，destroy-method。

1.2 Bean級生命週期介面方法

  Bean級生命週期方法：如BeanNameAware，BeanFactoryAware，InitializingBean和DisposableBean，這些介面由bean直接實現。

1.3 容器級生命週期介面方法

  容器級生命週期介面方法：有InstantiationAwareBeanPostProcessor和BeanPostProcessor這兩個介面實現，一般稱他們的實現類為後處理器。實現類獨立於bean，以容器附加裝置的形式註冊到spring當中。當spring建立任何bean時，這些後處理器都會發生作用，所以後處理器的影響是全域性性的。當然，使用者可以通過合理的編寫後處理器，讓其僅對感興趣的bean進行加工處理。

  Bean級生命介面和容器級生命介面是個性和共性辯證統一思想的體現。前者解決bean的個性化處理的問題，後者解決容器中某些bean共性化處理的問題。

1.4 工廠後處理器介面方法

  工廠級生命週期介面方法（BeanFactoryPostProcessor介面的實現類）,可以對bean的定義（配置元資料）進行處理。也就是說，Spring IoC容器允許BeanFactoryPostProcessor在容器實際例項化任何其它的bean之前讀取配置元資料，並有可能修改它。

2. bean生命週期演示示例

  下面通過一個例子來實際體驗一下bean的生命週期中的各個關鍵介面方法的呼叫。FruitStore類中定義了Bean自身方法以及Bean級生命週期方法：

public class FruitStore implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean{

    private String name;  
    private String address;  
    
    private ApplicationContext applicationContext;  
    private String             beanName;  
  
    public FruitStore() {  
        System.out.println("[FruitStore]--構造器");  
    }
    
    /** Bean自身方法 **/  
    
    // 通過<bean>的init-method屬性指定的初始化方法  
    public void myInit() {  
        System.out.println("[Bean自身方法] [init-method]  初始化方法...");  
    }  
      
    // 通過<bean>的destroy-method屬性指定的初始化方法  
    public void myDestory() {  
        System.out.println("[Bean自身方法] [destroy-method]  銷燬方法...");  
    }  
      
    public void sayHello() {  
        System.out.println("[Bean自身方法]  sayHello...");  
    }
    
    /** Bean級生命介面方法begin **/  
    
    public void setName(String name) {  
        this.name = name;  
        System.out.println("[Bean級介面] [注入屬性]  注入屬性name...");  
    }  
  
    public void setAddress(String address) {  
        this.address = address;  
        System.out.println("[Bean級介面] [注入屬性]  注入屬性address...");  
    }
    
    
    // DiposibleBean介面方法
    public void destroy() throws Exception {
        System.out.println("[Bean級介面]  銷燬方法...");
    }

    // InitializingBean介面方法
    public void afterPropertiesSet() throws Exception {
        System.out.println("[Bean級介面] [InitializingBean介面]  初始化方法...");
    }

    // BeanFactoryAware介面方法
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        this.applicationContext = arg0;  
        System.out.println("[Bean級介面] [ApplicationContextAware介面]  注入Spring容器ApplicationContext..."); 
    }

    // BeanNameAware介面方法
    public void setBeanName(String name) {
        this.beanName = name;  
        System.out.println("[Bean級介面] [BeanNameAware介面]  注入beanName...");
    }
    
    @Override  
    public String toString() {  
        return "FruitStore [name=" + name + 
                ", address=" + address + 
                ", applicationContext=" + applicationContext + 
                ", beanName=" + beanName + 
                "]";  
    } 
}

　　分別實現兩種容器級介面，首先是InstantiationAwareBeanPostProcessor介面：

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    
    public MyInstantiationAwareBeanPostProcessor() {  
        super();  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--構造器");  
    }  
  
    // 例項化Bean之前呼叫  
    @Override  
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--例項化Bean之前呼叫");  
        return null;  
    }  
  
    // 例項化Bean之後呼叫  
    @Override  
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--例項化Bean之後呼叫");  
        return true;  
    }  
  
    // 初始化Bean之前呼叫  
    @Override  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--初始化Bean之前呼叫");  
        return bean;  
    }  
  
    // 初始化Bean之後呼叫  
    @Override  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--初始化Bean之後呼叫");  
        return bean;  
    }  
  
    // 設定某個屬性時呼叫  
    @Override  
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,  
            String beanName) throws BeansException {  
        System.out.println("[容器級介面] [InstantiationAwareBeanPostProcessor實現類]--例項化Bean之後，設定某個屬性時呼叫");  
        return pvs;  
    }  
}

　　然後實現BeanPostProcessor介面：

public class MyBeanPostProcessor implements BeanPostProcessor{

    public MyBeanPostProcessor() {  
        System.out.println("[容器級介面] [MyBeanPostProcessor實現類]--構造器");  
    }  
  
    // 初始化Bean之前呼叫  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [BeanPostProcessor實現類]--初始化Bean之前呼叫");  
        return bean;  
    }  
  
    // 初始化Bean之後呼叫  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        System.out.println("[容器級介面] [BeanPostProcessor實現類]--初始化Bean之後呼叫");  
        return bean;  
    }  
}

　　工廠級生命週期介面方法（BeanFactoryPostProcessor介面的實現類）：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{

    public MyBeanFactoryPostProcessor() {  
        super();  
        System.out.println("[工廠級介面] [BeanFactoryPostProcessor實現類]--構造器");  
    }  
    
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0) throws BeansException {  
        System.out.println("[工廠級介面] [BeanFactoryPostProcessor實現類] Spring容器載入之後，所有Bean例項化之前呼叫");  
        // 重寫Person Bean的phone屬性  
        BeanDefinition bd = arg0.getBeanDefinition("fruitStore");  
        bd.getPropertyValues().addPropertyValue("name", "papaya-mangos");  
    }  
}

　　配置檔案：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    
        <!-- 定義工廠級生命週期介面. -->  
    <bean id="beanFactoryPostProcessor" class="spring.source.MyBeanFactoryPostProcessor"></bean>  
  
    <!-- 定義容器級生命週期介面. -->  
    <bean id="beanPostProcessor" class="xxx.xxx"></bean>  
    <bean id="instantiationAwareBeanPostProcessor" class="xxx.xxx"></bean>  
      
    <!-- 定義Bean自身及Bean級生命週期介面. -->  
    <bean id="fruitStore" class="xxx.xxx"   
            init-method="myInit"   
            destroy-method="myDestory"   
            scope="singleton">  
        <property name="name"    value="永輝超市"></property>  
        <property name="address" value="杭州"></property>   
    </bean>  
</beans>

　　測試程式碼：

public static void main(String[] args) {
        try{
            System.out.println("============================== 現在開始初始化容器. ==============================");
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");    
　　　　　　　System.out.println("\r\n============================== 容器初始化成功. ==============================");  
            //得到Preson，並使用  
            FruitStore fruitStore = ctx.getBean("fruitStore",FruitStore.class);  
            fruitStore.sayHello();  
            System.out.println(fruitStore);  
              
            System.out.println("\r\n============================== 現在開始關閉容器! ==============================");  
            ctx.close();  
        }catch (Exception e){
            e.printStackTrace();
        }
    }

　　執行結果為：

　　這裡再分析上述執行結果：

  1. 準備Spring容器

    • 例項化BeanFactoryPostProcessor實現類；
    • 執行BeanFactoryPostProcessor的postProcessBeanFactory修改XML對Bean配置的元資訊，這裡是改了一下fruitStore這個Bean的name屬性值；

  2. 例項化Bean

    • 例項化BeanPostProcessor實現類；
    • 例項化InstantiationAwareBeanPostProcessorAdapter實現類；
    • Bean例項化之前呼叫InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法；
    • 呼叫FruitStore的構造器進行例項化；
    • Bean例項化之後呼叫InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法；
    • 在屬性注入之前，呼叫InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法，可以修改Bean的屬性資訊；

  3. 注入依賴關係

    • 注入屬性：name、address；

  4. 初始化Bean

    • 注入BeanName；
    • 注入ApplicationContext；
    • 初始化Bean之前呼叫BeanPostProcessor實現類呼叫介面方法postProcessBeforeInitialization；
    • 初始化Bean之前呼叫InstantiationAwareBeanPostProcessor的postProcessBeforeInitialization方法；
    • 呼叫InitializingBean實現類的afterPropertiesSet()進行Bean的初始化；
    • 呼叫<bean>的init-method屬性指定的初始化方法；
    • 初始化Bean之後呼叫BeanPostProcessor實現類介面方法postProcessAfterInitialization；
    • 初始化Bean之後呼叫InstantiationAwareBeanPostProcessor的postProcessAfterInitialization方法；

  5. 使用Bean

    • 呼叫sayHello()方法；
    • 列印FruitStore資訊(可以發現名稱name已改為papaya-mangos，和配置檔案中不同)；

  6. 銷燬Bean

    • 呼叫DiposibleBean介面的destory方法；
    • 呼叫<bean>的destroy-method屬性指定的銷燬方法；

3. 總結

  本文我們總結了Spring中Bean的生命週期，主要有如下流程：

  • Spring容器準備，這裡可以應用工廠級別的後處理器BeanFactoryPostProcessor的實現類；
  • 例項化Bean，這裡可以應用容器級別的後處理InstantiationAwareBeanPostProcessor的實現類來在例項化Bean前後做一些處理；
  • 依賴注入，這裡可以應用容器級別後處理器InstantiationAwareBeanPostProcessor的實現類來在屬性注入之前做一些處理；
  • 對Bean進行初始化，這裡可以應用Bean級生命週期介面方法(BeanNameAware、InitializingBean等介面)及容器級後處理器BeanPostProcessor實現類；
  • 使用Bean；
  • 銷燬Bean，這裡會應用Bean級生命週期介面方法DisposableBean及Bean自身方法destroy-method；

  總結了常見的配置Bean生命週期的方式主要有三種：

  • 繼承介面，如BeanNameAware、InitializingBean等；
  • 配置xml配置檔案，如init-method，destroy-method；
  • 新增處理器，如實現BeanPostProcessor；

  通過<bean>的init-method和destroy-method屬性配置方式為bean指定初始化和銷燬的方法，採用這種方式的效果和通過實現InitializingBean，DisposableBean介面所達到的效果是完全相同的，但是採用前者配置方式可以使bean不需要和特定的spring介面繫結，前者是和spring“不對應用程式類作任何限制”的理論相符合的。

  而像BeanPostProcessor這類的後處理器介面則不一樣，它不要求bean去繼承它，而是完全像外掛一樣註冊到spring容器中，為容器提供額外的功能。spring充分利用了BeanPostProcessor對bean進行加工處理（SpringAOP以此為基礎，後面會細說）。

　　spring作為ioc容器其核心功能就是管理bean的建立以及bean之間的依賴關係，再進一步就是說spring管理bean的整個生命週期，從例項化到初始化，再到快取建立好的bean以及銷燬bean。在這個過程中，spring提供了多種方式(如上所述)，使得使用者可以在bean的整個生命週期中方便地做一些自定義的操作。這也是spring中體現出來的一種優秀的設計方法論，easy to change，對擴充套件開放。

 

&n

相關推薦

spring原始碼閱讀筆記10：bean生命週期

　　前面的文章主要集中在分析Spring IOC容器部分的原理，這部分的核心邏輯是和bean建立及管理相關，對於單例bean的管理，從建立好到快取起來再到銷燬，其是有一個完整的生命週期，並且Spring也在整個bean的建立過程中提供了多處介面供使用者自己擴充套件，本文就來梳理一下Spring中的bean生命

spring原始碼閱讀筆記06：bean載入之準備建立bean

　　上文中我們學習了bean載入的整個過程，我們知道從spring容器中獲取單例bean時會先從快取嘗試獲取，如果快取中不存在已經載入的單例bean就需要從頭開始bean的建立，而bean的建立過程是非常複雜的，本文就開始研究bean載入這部分的原始碼。 1. bean建立流程分析 　　在Spring中bea

Spring原始碼閱讀筆記(二)：ApplicationContext初始化簡要流程

基於Spring框架的應用，最主要的亮點就是bean的IoC。而IoC容器的配置、組裝由ApplicationContext完成，那麼我們就從這裡開始，去探究IoC如何管理到bean物件。 ApplicationContext初始化簡要流程 Spring

Spring原始碼閱讀筆記03：xml配置讀取

　　前面的文章介紹了IOC的概念，Spring提供的bean容器即是對這一思想的具體實現，在接下來的幾篇文章會側重於探究這一bean容器是如何實現的。在此之前，先用一段話概括一下bean容器的基本工作原理。顧名思義，bean容器的作用是替我們管理bean物件(簡單的Java類物件)的。不管框架如何強大，還是需

Spring原始碼閱讀筆記05：自定義xml標籤解析

　　在上篇文章中，提到了在Spring中存在預設標籤與自定義標籤兩種，並且詳細分析了預設標籤的解析，本文就來分析自定義標籤的解析，像Spring中的AOP就是通過自定義標籤來進行配置的，這裡也是為後面學習AOP原理打下基礎。 　　這裡先回顧一下，當Spring完成了從配置檔案到Document的轉換並提取對應

spring原始碼閱讀筆記09：迴圈依賴

　　前面的文章一直在研究Spring建立Bean的整個過程，建立一個bean是一個非常複雜的過程，而其中最難以理解的就是對迴圈依賴的處理，本文就來研究一下spring是如何處理迴圈依賴的。   1. 什麼是迴圈依賴   不管之前是否研究過迴圈依賴，這裡先對這個知識做一點回顧。   迴圈依賴就是迴圈引

白話Spring原始碼（五）：Bean的建立過程

我們知道可以通過name從beanFactory獲取對應bean物件，那bean是怎麼建立的呢？ 我們先設想如果我們來建立物件需要哪幾步呢？ 1.找到物件的class 2.通過反射建立物件 3.設定物件的屬性值 其實spring建立物件的也是主要分這幾步，下面我們進入原始碼看看吧

Spring原始碼解析筆記(一)：Spring的整體架構

前言：此筆記來源於《Spring原始碼深度解析》。 1、Core Container       Core Container包括：Core、Beans、Context和Expression Language模組   &n

jvm原始碼閱讀筆記[3]：從記憶體分配到觸發GC的細節

         除了第一篇說到的，對於使用cms回收的應用，會有執行緒輪詢判斷老年代是否滿足GC的條件，若滿足，則會觸發一次cms老年代的回收。     針對年輕代，更常見的是，執行緒優先在eden區分配物件的時候，若eden區空間不足，則會觸發一次y

jvm原始碼閱讀筆記[5]：記憶體分配失敗觸發的GC究竟對記憶體做了什麼？

         在第3篇文章中，我們總結到，當分配記憶體失敗時，會通過VM觸發一次由分配失敗觸發的一次GC，也就是我們經常能在GC日誌裡面看到的“allocation failure” VM_GenCollectForAllocation op(s

Spring原始碼閱讀——bean的載入過程解析

前言 在上一節中，我們已經瞭解過Spring對bean從XML中提取，並且以BeanDefinition型別解析註冊到Spring的DefaultListableBeanFactory中取了，那麼，接下來就應該來看下我們在Spring中獲取一個例項過程中，bean是如何載入成為我們需

白話Spring原始碼（一）：怎麼閱讀原始碼

跟大家分享Spring原始碼前我想先聊聊： 為什麼要閱讀原始碼？ 怎麼閱讀原始碼？ 希望大家在學習某個新的知識前多問幾個為什麼，好奇心是我們學習的一大動力。 一、為什麼要閱讀原始碼 剛入行時，我們會接觸很多框架：spirng，Struts，Hibernate，mybatis等等，

Spring原始碼學習筆記 （一）bean是怎麼生成的

bean 實在 bean 重新整理過程中產生的，首先我們看下 bean 的重新整理方法。下面是 AbstractApplicationContext 的 refresh 方法。 @Override public void refresh() throws

JAVA 10原始碼閱讀筆記之JEP-307（G1的並行Full GC）

# 1. 背景 JEP-307解決了G1垃圾回收器的一個嚴重的問題，截止到Java 9，G1的Full GC採用的是單執行緒演算法，嚴重影響效能，無法利用到多核能力進行垃圾回收。JEP-307修復了此問題，發生Full GC時允許使用多個執行緒進行並行回收。 # 2. G1

Spring原始碼系列 — Bean生命週期

前言 上篇文章中介紹了Spring容器的擴充套件點，這個是在Bean的建立過程之前執行的邏輯。承接擴充套件點之後，就是Spring容器的另一個核心：Bean的生命週期過程。這個生命週期過程大致經歷了一下的幾個階段 在本節中重點介紹例項化、填充裝配、喚醒Aware方法、BeanPostProce

spring原始碼閱讀（1）- ioc依賴注入之bean載入

還是先看下DefaultListableBeanFactory的類結構圖  我們從User user = (User) beanFactory.getBean("user");入手進入bean的載入管理流程。 這裡還是堅持走主線的流程，去掉無關的枝葉，儘量讓業務變得簡

【Spring原始碼閱讀】 preInstantiateSingletons方法分析，單例Bean獲取/例項化流程

在初始化ClassPathXmlApplicatonContext過程中，核心初始化邏輯在AbstractApplicationContext的refresh函式中： public void refresh() throws BeansException, IllegalStateE

Tensorflow object detection API 原始碼閱讀筆記：RPN

Update: 建議先看從程式設計實現角度學習Faster R-CNN，比較直觀。這裡由於原始碼抽象程度較高，顯得比較混亂。 faster_rcnn_meta_arch.py中這兩個對應知乎文章中RPN包含的3*3和1*1卷積： rpn_box_pred

Spring原始碼閱讀——Bean的載入和獲取過程

我們經常使用Spring，並且也都瞭解其大概原理。我想我們一定會對Spring原始碼的解讀有迫切的渴望。 我也如此。所以，我打算閱讀一下Spring的原始碼。再此之前，我也為此準備了很多。包括，去複習熟練java反射，理解常用的設計模式。當然，這些複習筆記也會在今後的複習中

Tensorflow object detection API 原始碼閱讀筆記：架構

在之前的博文中介紹過用tf提供的預訓練模型進行inference，非常簡單。這裡我們深入原始碼，瞭解檢測API的程式碼架構，每個部分的深入閱讀留待後續。 '''構建自己模型的介面是虛基類DetectionModel，具體有5個抽象函式需要實現。 ''' o