2. 程式人生 > >Spring Bean生命週期詳解

Spring Bean生命週期詳解

阿新 • • 發佈：2018-12-13

  在Spring中 Bean 可謂是一個核心的元素，當我們結合Spring進行程式設計的時候也離不開Bean，面對這樣重要的一個角色，瞭解其生命週期和該生命週期所涉及的環節對我們更加熟練靈活地使用Bean是很有Bean必要的，下面我們就來詳細分析下Bean的生命週期吧。

生命週期流程圖

  我們先通過一個流程圖，對Bean的生命週期先做一個整體的認識和了解。 這裡寫圖片描述   若容器實現了流程圖中涉及的介面，程式將按照以上流程進行。需要我們注意的是，這些介面並不是必須實現的，可根據自己開發中的需要靈活地進行選擇，沒有實現相關介面時，將略去流程圖中的相關步驟。

介面方法的分類

  上面流程圖當中涉及呼叫很多的方法，可能我們直接去理解和記憶比較困難，其實對於這麼一大堆方法我們可以根據它們的特點對他們進行整理分類，下面提供一種可供大家參考的分類模型：

分類型別 所包含方法
Bean自身的方法 配置檔案中的init-method和destroy-method配置的方法、Bean物件自己呼叫的方法
Bean級生命週期介面方法 BeanNameAware、BeanFactoryAware、InitializingBean、DiposableBean等介面中的方法
容器級生命週期介面方法 InstantiationAwareBeanPostProcessor、BeanPostProcessor等後置處理器實現類中重寫的方法

  這時回過頭再來看這些方法輪廓上就比較清晰了，記憶的時候我們可通過記憶分類的型別來理解性的記憶所涉及的方法。

程式設計實踐

  有了上面的理論分析，我們再來通過程式設計實踐來驗證下我們的結論，順便進一步加深我們對整個生命週期的理解。

準備工作

編寫測試Bean

  我們先編寫一個測試Bean來實現流程圖中的相關介面.    StudentBean.java 

package com.yanxiao.cyclelife;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import
 
 org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * 測試生命週期的Bean
 * Created by yanxiao on 2016/8/1.
 */
public class StudentBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {
    private String name;
    private int age;

    private String beanName;//實現了BeanNameAware介面，Spring可以將BeanName注入該屬性中
    private BeanFactory beanFactory;//實現了BeanFactory介面，Spring可將BeanFactory注入該屬性中


    public StudentBean(){
        System.out.println("【Bean構造方法】學生類的無參構造方法");
    }

    @Override
    public String toString() {
        return "StudentBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", beanName='" + beanName + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【set注入】注入學生的name屬性");
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("【set注入】注入學生的age屬性");
        this.age = age;
    }

    /**
     * 自己編寫的初始化方法
     */
    public void myInit(){
        System.out.println("【init-method】呼叫init-method屬性配置的初始化方法");
    }

    /**
     * 自己編寫的銷燬方法
     */
    public void myDestroy(){
        System.out.println("【destroy-method】呼叫destroy-method屬性配置的銷燬方法");
    }

    /**
     * BeanFactoryAware介面的方法
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("【BeanFactoryAware介面】呼叫BeanFactoryAware的setBeanFactory方法得到beanFactory引用");
    }

    /**
     * BeanNameAware介面的方法
     * @param name
     */
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("【BeanNameAware介面】呼叫BeanNameAware的setBeanName方法得到Bean的名稱");
    }

    /**
     * InitializingBean介面的方法
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean介面】呼叫InitializingBean介面的afterPropertiesSet方法");
    }

    /**
     * DisposableBean介面的方法
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("【DisposableBean介面】呼叫DisposableBean介面的destroy方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105

  上面程式碼中的 myInit() 和 ·myDestroy()· 方法供我們在配置檔案中通過init-method和destroy-method屬性進行指定。

實現BeanPostProcessor介面

  我們編寫BeanPostProcessor介面的一個實現類: MyBeanPostProcessor.java

package com.yanxiao.cyclelife;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * Created by yanxiao on 2016/8/1.
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor(){
        System.out.println("【BeanPostProcessor介面】呼叫BeanPostProcessor的構造方法");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor介面】呼叫postProcessBeforeInitialization方法，這裡可對"+beanName+"的屬性進行更改。");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor介面】呼叫postProcessAfterInitialization方法，這裡可對"+beanName+"的屬性進行更改。");
        return bean;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

實現BeanPostProcessor介面

  編寫BeanPostProcessor介面的一個實現類 MyBeanPostProcessor.java 

package com.yanxiao.cyclelife;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * Created by yanxiao on 2016/8/1.
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor(){
        System.out.println("【BeanPostProcessor介面】呼叫BeanPostProcessor的構造方法");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor介面】呼叫postProcessBeforeInitialization方法，這裡可對"+beanName+"的屬性進行更改。");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor介面】呼叫postProcessAfterInitialization方法，這裡可對"+beanName+"的屬性進行更改。");
        return bean;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

實現InstantiationAwareBeanPostProcessor介面

  實現InstantiationAwareBeanPostProcessor介面，為了程式設計方便我們直接通過繼承Spring中已經提供的一個實現了該介面的介面卡類InstantiationAwareBeanPostProcessorAdapter來進行測試。

MyInstantiationAwareBeanPostProcessor.java 

package com.yanxiao.cyclelife;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

/**
 * 一般情況下，當我們需要實現InstantiationAwareBeanPostProcessor介面時，是通過繼承Spring框架中InstantiationAwareBeanPostProcessor介面實現類
 * InstantiationAwareBeanPostProcessorAdapter這個介面卡類來簡化我們實現介面的工作
 * Created by yanxiao on 2016/8/1.
 */
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

    public MyInstantiationAwareBeanPostProcessor() {
        System.out.println("【InstantiationAwareBeanPostProcessor介面】呼叫InstantiationAwareBeanPostProcessor構造方法");
    }

    /**
     * 例項化Bean之前呼叫
    */
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println("【InstantiationAwareBeanPostProcessor介面】呼叫InstantiationAwareBeanPostProcessor介面的postProcessBeforeInstantiation方法");
        return ;
    }

    /**
     * 例項化Bean之後呼叫
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【InstantiationAwareBeanPostProcessor介面】呼叫InstantiationAwareBeanPostProcessor介面的postProcessAfterInitialization方法");
        return bean;
    }

    /**
     * 設定某個屬性時呼叫
     */
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {
        System.out.println("【InstantiationAwareBeanPostProcessor介面】呼叫InstantiationAwareBeanPostProcessor介面的postProcessPropertyValues方法");
        return pvs;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

BeanFactoryPostProcessor介面

  我們編寫BeanFactoryPostProcessor介面的一個實現類 BeanFactoryPostProcessor.java 

package com.yanxiao.cyclelife;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

/**
 * Created by yanxiao on 2016/8/1.
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        System.out.println("【BeanFactoryPostProcessor介面】呼叫BeanFactoryPostProcessor實現類構造方法");
    }

    /**
     * 重寫BeanFactoryPostProcessor介面的postProcessBeanFactory方法，可通過該方法對beanFactory進行設定
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        System.out.println("【BeanFactoryPostProcessor介面】呼叫BeanFactoryPostProcessor介面的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("studentBean");
        beanDefinition.getPropertyValues().addPropertyValue("age", "21");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

編寫Spring配置檔案beans.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <!--配置Bean的後置處理器-->
    <bean id="beanPostProcessor" class="com.yanxiao.cyclelife.MyBeanPostProcessor">
    </bean>

    <!--配置instantiationAwareBeanPostProcessor-->
    <bean id="instantiationAwareBeanPostProcessor" class="com.yanxiao.cyclelife.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <!--配置BeanFactory的後置處理器-->
    <bean id="beanFactoryPostProcessor" class="com.yanxiao.cyclelife.MyBeanFactoryPostProcessor">
    </bean>

    <bean id="studentBean" class="com.yanxiao.cyclelife.StudentBean" init-method="myInit"
          destroy-method="myDestroy" scope="singleton">
        <property name="name" value="yanxiao"></property>
        <property name="age" value="21"></property>
    </bean>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

進行測試

  通過上面的準備工作我們已經把相關的類和測試檔案編寫完畢，下面我們就通過測試程式碼來驗證我們的成果。

package com.yanxiao.cyclelife;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by yanxiao on 2016/8/1.
 */
public class TestCyclelife {

    public static void main(String[] args){
        System.out.println("--------------【初始化容器】---------------");

        ApplicationContext context = new ClassPathXmlApplicationContext("META-INF/beans1.xml");
        System.out.println("-------------------【容器初始化成功】------------------");
        //得到studentBean，並顯示其資訊
        StudentBean studentBean = context.getBean("studentBean",StudentBean.class);
        System.out.println(studentBean);

        System.out.println("--------------------【銷燬容器】----------------------");
        ((ClassPathXmlApplicationContext)context).registerShutdownHook();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

測試結果

這裡寫圖片描述   執行結果符合我們預期，成功驗證之前的結論。

相關推薦

Spring Bean生命週期詳解

  在Spring中 Bean 可謂是一個核心的元素，當我們結合Spring進行程式設計的時候也離不開Bean，面對這樣重要的一個角色，瞭解其生命週期和該生命週期所涉及的環節對我們更加熟練靈活地使用Bean是很有Bean必要的，下面我們就來詳細分析下Bean的生

Spring IOC -bean物件的生命週期詳解(補充,含程式碼)

生命週期執行的過程如下:1) spring對bean進行例項化,預設bean是單例2) spring對bean進行依賴注入3) 如果bean實現了BeanNameAware介面,spring將bean的id傳給setBeanName()方法4) 如果bean實現了BeanFactory

Spring bean的生命週期詳解

Spring作為當前Java最流行、最強大的輕量級框架，運用十分廣泛。準確的瞭解Spring Bean的生命週期是非常必要的。因為或許我們需要利用spring提供的擴充套件點來自定義bean的建立過程。下圖展示了bean載入spring應用上下文的整個生命週期。 詳細步

Spring IOC -bean物件的生命週期詳解

生命週期執行的過程如下:1)spring對bean進行例項化,預設bean是單例2)spring對bean進行依賴注入3)如果bean實現了BeanNameAware介面,spring將bean的id傳給setBeanName()方法4)如果bean實現了BeanFactoryAware介面,spring將呼

5.Spring Bean生命週期.md

文章目錄 5.Spring Bean生命週期 生命週期流程圖 說明 總結 5.Spring Bean生命週期 生命週期流程圖 說明 *呼叫InstantitationAwareBeanP

Spring Bean生命週期回撥——初始化回撥(init-method）與銷燬回撥（destroy-method）

實現Bean初始化回撥和銷燬回撥各有三種方法，一是實現介面方法，二是在XML配置，三是使用註解 初始化回撥（init-method） 1、使用介面 org.springframework.beans.factory.InitializingBean介面類的作用是：在容器設定bean必

React - 元件的生命週期詳解（及各階段呼叫的方法）

轉自http://www.hangge.com/blog/cache/detail_1473.html React - 元件的生命週期詳解（及各階段呼叫的方法） 2016-12-22釋出：hangge閱讀：2699 ReactJS 的核心思想是元件化，即按功能封裝成一個一個的元

Servlet簡介及其生命週期詳解

簡介        Servlet生命週期，即闡述Servlet從產生到毀滅的整個過程。         在Servlet產生到消亡的過程中，有三個生

Android View的onFinishInflate和onSizeChanged生命週期詳解

1、onFinishInflate 從字面上來看這個方法的作用就是在完成View的佈局例項化後的回撥，關於佈局例項化的內容（LayoutInflater）的學習網址：LayoutInflater原理，通過對這篇部落格的 學習可以得知：這個回撥方法是在整個佈局檔案都例項化結束後每個View才進

vue 生命週期詳解

每個Vue例項在被建立之前都要經過一系列的初始化過程,這個過程就是vue的生命週期。下面是生命週期圖   可以看到在vue一整個的生命週期中會有很多鉤子函式提供給我們在vue生命週期不同的時刻進行操作, 那麼先列出所有的鉤子函式，然後我們再一一詳解: befo

spring bean註解使用詳解

@Bean 的用法 @Bean是一個方法級別上的註解，主要用在@Configuration註解的類裡，也可以用在@Component註解的類裡。新增的bean的id為方法名 定義bean 下面是@Configuration裡的一個例子 @Configuration publi

vue生命週期詳解

初心-楊瑞超個人部落格誠邀您加入qq群(IT-程式猿-技術交流群)：757345416 先上圖: 下面我們用例項來理解生命週期： <div class="test" style="border: 1px black dashed;padding: 8

Vue2 生命週期詳解

<script> /** * Vue生命週期解析 */ export default { /** * name: name * type: string * explain: 允許元件模板遞迴地呼叫自身。 * 注意，元件在全域性用 Vue.compon

【vue】vue的生命週期詳解

vue的生命週期詳解 不多BB先上圖 可以看到在vue一整個的生命週期中會有很多鉤子函式提供給我們在vue生命週期不同的時刻進行操作,，那麼先列出所有的鉤子函式，然後我們再進行詳解： beforeCreate——建立前 created——建立後

react生命週期詳解

React的生命週期分為三個階段：1.初始化階段 2.更新階段 3.銷燬階段 一，初始化階段 （1） 方法：getDefaultProps(); 作用：作用於元件類，只調用一次，獲取預設的props，也可以用dufaultProps設定元件的預設屬性； 注意： （2） 方法：

spring-bean生命週期之初始化和銷燬的三種方式

1，註解bean之指定init-method/destroy-method 這種方式spring註解之@Bean註解，這邊再簡單演示如下： 配置類中增加一個bean如下： /** * 定義一個bean物件 * @return */

Servlet的生命週期詳解

敘述Servlet的生命週期其實就是找出Servlet是怎麼出生的又是怎麼消失的一個過程。我們從最主要的三個方法去記錄Servlet產生與消失的過程： 初始化階段，呼叫init方法： 初始化階段。

vue 生命週期詳解

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <st

Spring Bean生命週期

spring bean的生命週期 spring bean生命週期1、Spring對bean進行例項化； 2、Spring將值和bean的引用注入到bean對應的屬性中； 3、如果bean實現了BeanNameAware介面，Spring將bean的ID傳遞給setBea

Activity與Fragment的生命週期詳解

在安卓中Activity與Fragment是非常相似的兩個類，它們各自都擁有自己的生命週期，且都可以用來顯示佈局檔案中的檢視。其中Activity是通過setContenView()顯示檢視，而Fra