2. 程式人生 > >Spring學習5（3）：Bean的生命週期

Spring學習5（3）：Bean的生命週期

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

Spring學習5（3）

 Bean生命週期由多個特定的生命階段組成，每個生命階段都開出介面，允許外界由此對Bean施加控制。  在spring中有兩個層面來定義Bean的生命週期，一個是Bean的作用範圍，一個是例項化Bean時所經歷的一系列階段。

BeanFactory中Bean的生命週期

生命週期圖解

在這裡插入圖片描述

 具體呼叫過程如下：

  1. 當呼叫getBean()來請求某一個Bean時，如果容器註冊了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor介面則會在例項化Bean之前，將呼叫介面的postProcessBeforeInstantiation()
    方法。
  2. 根據配置情況呼叫Bean建構函式或工廠方法例項化Bean。
  3. 如果容器註冊了在步驟1中的那個介面那麼在例項化Bean後，可以呼叫介面的postProcessAfterInstantiation()方法來對已經例項化的物件做一點“梳妝打扮”。
  4. 如果Bean配置了屬性資訊，那麼容器在這一步將配置值設定到Bean對應屬性中，不過在設定每個屬性之前可以呼叫步驟1介面的postProcessPropertyValues()方法。
  5. 呼叫Bean的屬性設定方法設定屬性值。
  6. 如果Bean實現了org.springframework.bean.factory.BeanNameAware介面則將呼叫setBeanName()介面方法，將配置檔案中該Bean對應的名稱設定到Bean中。
  7. 如果Bean實現了org.springframework.beans.factory.BeanFactoryAware則將嗲用setBeanFactory()方法將BeanFactory容器例項設定到Bean中。
  8. 如果BeanFactory裝配了org.springframework.beans.factory.config.BeanPostProcessor，則呼叫BeanPostProcessor的Objetc:postProcessBeforeInitialization(Object bean, String beanName)這個函式提供當前正在處理的Bean以及beanName（當前Bean的配置名）返回加工處理後的Bean。這個方法可以對某些Bean進行特殊的處理，甚至改變Bean的行為，是spring框架中的重要方法，為容器提供對Bean進行後續加工處理的切入點，spring容器所提供的各種功能如Aop，動態代理等都經過BeanPostProcessor來實施。
  9. 如果Bean實現了InitializingBean的介面afterPropertiesSet()方法。
  10. 如果在<bean>中通過了init-method定義了初始化方法，則將執行這個方法。
  11. BeanPostProcessor除了步驟8中的方法還定義了postProcessAfterInitialization(Object bean, String beanName)方法，此時會呼叫這個方法讓容器再次獲得對Bean進行加工的機會。
  12. 如果在<bean>中指定Bean的作用範圍為scope="prototype"則將Bean返回給呼叫者，spring不再管理Bean的生命週期；如果指定為scope="singletion"則將Bean放入springIoC容器的快取池中，並將Bean引用放回給呼叫者，spring繼續對這些Bean進行後續的生命管理。
  13. 對於scope="singleton"的Bean(預設情況)，當容器關閉時，如果Bean實現了DisposableBean介面，則將呼叫介面的destory()方法，可以在此編寫釋放資源，記錄日誌等操作。
  14. 對於scope="singletion"的Bean，如果通過<bean>的destroy-method屬性指定了Bean的銷燬方法，那麼Spring將執行Bean的這個方法，完成Bean資源的釋放。

Bean生命週期例項

 採用之前用過的Car類，讓它實現所有Bean級的生命介面。  我們修改com.smart下Car.java檔案為如下程式碼：

package com.smart;

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

public class Car implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean{
	private String brand;
	private String color;
	private int maxSpeed;
	
	private BeanFactory beanFactory;
	private String beanName;
	public Car() {
		System.out.println("呼叫Car()建構函式。");
		
	}
	
	public Car(String brand, String color, int maxSpeed) {
		this.brand = brand;
		this.color = color;
		this.maxSpeed = maxSpeed;
	}
	
	public void introduce() {
		System.out.println("brand:"+brand+";color:"
				+ color+";maxSpeed:"
				+ maxSpeed+".");
	}
	
	public void setBrand(String brand) {
		this.brand = brand;
		System.out.println("呼叫setBrand()設定屬性。");
	}
	
	public void setColor(String color) {
		this.color = color;
		System.out.println("呼叫setColor()設定屬性。");
	}
	
	public void setMaxSpeed(int maxSpeed) {
		this.maxSpeed = maxSpeed;
		System.out.println("呼叫setMaxSpeed()設定屬性。");
	}
	
	//BeanFactoryAwawre介面方法
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException{
		System.out.println("呼叫BeanFactoryAware.setBeanFactory().");
		this.beanFactory = beanFactory;
	}
	
	//BeanNameAware介面方法
	public void setBeanName(String beanName) {
		System.out.println("呼叫BeanNameAware.setBeanName().");
		this.beanName = beanName;
	}
	
	//InitializingBean介面方法
	public void afterPropertiesSet() throws Exception{
		System.out.println("呼叫InitializingBean.afterPropertiesSet().");
		
	}
	
	//DisposableBean介面方法
	public void destroy() throws Exception{
		System.out.println("呼叫DisposableBean.destroy().");
	}
	
	//通過<bean>的init-method屬性指定的初始化方法
	public void myInit() {
		System.out.println("呼叫init-method所指定的myInit(),將maxSpeed設定為240.");
		this.maxSpeed = 240;
	}
	
	//通過<bean>的destroy-method屬性指定的銷燬方法
	public void myDestroy() {
		System.out.println("呼叫destroy-method所指定的myDestroy().");
	}
}

 這裡實現了BeanFactoryAware, BeanNameAware,InitializingBean,DisposableBean等Bean級的生命週期介面，在下面定義了myInit()和myDestroy()方法，這兩個方法就可以在<bean>中通過init-method和destroy-method方法。

 MyInstantiationAwareBeanPostProcessor通過擴充套件InstantiationAwareBeanPostProcessor介面卡InstatiationAwareBeanPostProcessorAdapter提供實現。我們在com.smart.beanfactory中增加myInstantiationAwareBeanPostProcessor.java，程式碼如下：

package com.smart.beanfactory;
import java.beans.PropertyDescriptor;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.
InstantiationAwareBeanPostProcessorAdapter;
import com.smart.Car;
public class MyInstantiationAwareBeanPostProcessor extends 
InstantiationAwareBeanPostProcessorAdapter{
	
	//介面：在例項化Bean前呼叫
	public Object postProcessBeforeInstantiation(Class beanClass, String beanName)
		throws BeansException{
		if("car1".equals(beanName)) {
			System.out.println("InstantiationAware BeanPostProcessor.postProcess"
					+ "	BeforeInstantiation");
		}
		return null;
	}
	
	//介面：在例項化Bean後呼叫
	public boolean postProcessAfterInstantiation(Object bean, String beanName)
		throws BeansException{
		if("car1".equals(beanName)) {
			System.out.println("InstantiationAware BeanPostProcessor.postProcess"
					+ "		AfterInstantiation");
		}
		return true;
	}
	//介面：在設定某個屬性時呼叫
	public PropertyValues postProcessPropertyValues(
		PropertyValues pvs,PropertyDescriptor[] pds, Object bean, String beanName)
		throws BeansException{
		if("car1".equals(beanName)) {
			System.out.println("Instantiation AwareBeanPostProcessor.postProcess"
					+ "PropertyValues");
		}
		return pvs;
	}
}

 除此之外spring還有一個BeanPostProcessor實現類，對配置檔案所提供的屬性設定值進行判斷，並執行相應的“補缺補漏操作”，在程式碼清單如下：

package com.smart.beanfactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import com.smart.Car;
public class MyBeanPostProcessor implements BeanPostProcessor{
	public Object postProcessBeforeInitialization(Object bean, String beanName)
		throws BeansException{
		if(beanName.equals("car1")) {
			Car car = (Car)bean;
			if(car.getColor() == null) {
				System.out.println("呼叫BeanPostProcessor.postProcess"
						+ "	BeforeInitialization(), color is empty, default color is black");
				car.setColor("黑色");
				
			}
		}
		return bean;
	}
	
	public Object postProcessAfterInitialization(Object bean, String beanName)
		throws BeansException{
		if(beanName.equals("car1")) {
			Car car = (Car)(bean);
			if(car.getMaxSpeed() >= 200) {
				System.out.println("呼叫BeanPostProcessor.postProcess"
						+ "AfterInitialization(), modify maxSpeed to 200.");
				car.setMaxSpeed(200);
			}
		}
		return bean;
	}
}

註冊介面

 上述這寫介面除了在Car.java中直接定義的介面其他的介面都需要註冊載入。首先我們在beans.xml中註冊myInit和myDestroy方法。程式碼更改如下：

	<bean id="car1" class="com.smart.Car"
	init-method="myInit"
	destroy-method="myDestroy"
	p:brand="紅旗CA72"
	p:color="黑色"
	p:maxSpeed="200"
	/>
	</beans>

 下面讓容器裝載配置檔案，然後分別註冊上面所提供的兩個後處理器。在com.smart.beanfactory下建立BeanLifeCycle.java檔案，程式碼如下：

package com.smart.beanfactory;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.smart.Car;
public class BeanLifeCycle{
	private static void LifeCycleInBeanFactory() {
		//裝載配置檔案並啟動容器
		Resource res = new ClassPathResource("com/smart/beanfactory/beans.xml");
		BeanFactory bf = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf);
		reader.loadBeanDefinitions(res);
		
		//向容器註冊MyBeanPostProcessor後處理器
		((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());
		
		//向容器中註冊MyInstantiationAwareBeanPostProcessor後處理器
		((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
		
		//第一次從容器中獲取car，將出發容器例項化Bean,將引發生命週期方法的呼叫
		Car car1 = (Car)bf.getBean("car1");
		car1.introduce();
		car1.setColor("紅色");
		
		//第二次從容器中獲取Car，直接從快取池中獲取
		Car car2 = (Car)bf.getBean("car1");
		
		//檢視car1和car2是否指向同一引用
		System.out.println("car1 == car2:" + (car1==car2));
		
		//關閉容器
		((DefaultListableBeanFactory)bf).destroySingletons();
	}
	
	public static void main(String[] args) {
		LifeCycleInBeanFactory();
	}
}

 這裡需要注意的是多個後處理器的呼叫順序和註冊順序無關，必須通過實現org.springframework.core.Ordered介面來確定呼叫順序。  執行該程式碼即可基本瞭解呼叫的過程。

ApplicationContext中Bean的生命週期

 書中給出的生命週期圖如下： 在這裡插入圖片描述  可以看到在Application只是多了幾個步驟：

  1. 如果Bean實現了org.springframework.context.ApplicationContextAware介面則會增加一個呼叫該介面方法setApplicationContext()的步驟
  2. 如果在配置檔案中申明瞭後處理介面BeanFactoryPostProcessor的實現類，則應用上下文在裝載配置檔案之後，初始化例項之前將呼叫BeanFactoryPostProcessor對配置資訊進行加工處理。

 除此之外，ApplicationContext會利用java的反射機制自動識別出配置檔案中定義的BeanPostProcessor等後處理器並註冊到上下文中，而不像BeanFactory需要手工呼叫addBeanPostProcessor()進行註冊。

例項

 假設我們希望對配置檔案中car1的brand配置屬性進行調整。在com.smart.context建立一個MyBeanFactoryPostProcessor.java，程式碼如下：

package com.smart.context;
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;
import com.smart.Car;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{
	//對car的brand配置資訊進行加工操作
	public void postProcessBeanFactory(ConfigurableListableBeanFactory bf)
		throws BeansException{
		BeanDefinition bd = bf.getBeanDefinition("car1");
		bd.getPropertyValues().addPropertyValue("brand", "奇瑞QQ");
		System.out.println("呼叫BeanFactoryPostProcessor.postProcessBean Factory()");
		
	}
}

 ApplicationContext在啟動時，將首先為配置檔案中的每一個<bean>生成一個BeanDefinition物件（<bean>在spring容器中的內部表示）而後我們就有機會對其進行修改。  接下來對beans.xml修改：

<bean id="car1" class="com.smart.Car"
	init-method="myInit"
	destroy-method="myDestroy"
	p:brand="紅旗CA72"
	p:color="黑色"
	p:maxSpeed="200"
	/>
	<bean id = "myBeanFactoryPostProcessor"
		class = "com.smart.context.MyBeanFactoryPostProcessor"/>

相關推薦

Spring學習5（3）：Bean的生命週期

Spring學習5（3）  Bean生命週期由多個特定的生命階段組成，每個生命階段都開出介面，允許外界由此對Bean施加控制。  在spring中有兩個層面來定義Bean的生命週期，一個是Bean的作用範圍，一個是例項化Bean時所經歷的一系列階段。 BeanF

Spring學習5（1）：IoC容器之IoC概述，JAVA反射機制，資源訪問器

spring學習5（1）  在經過了對spring框架基本開發的瞭解以及對spring boot流程的學習，《精通spring4.x…》這本書正式開始了spring的講解，我也跟隨著這本書的腳步進行學習。 IoC概述  首先需要學習的是spring的IoC技術，

spring學習筆記（3）——bean配置細節註意

collect 1.5 之前 ice ble person name return 引用 1. 一個bean引用另外一個bean 當Person類中有一個屬性是Car，那麽該如何配置呢 person： package com.zj.spring; public class

Spring JDBC學習筆記（3）：使用JdbcTemplate來獲取資料庫表和列的元資料

本篇文章才是我寫這一個系列文章的目的，原來我一般都是使用jdbc獲取資料庫的元資料，但是有點讓我很不爽，每次查資料表和列的時候都要自己寫“TABLE_NAME”和“COLUMN_HOME”等名稱，所以乾脆轉到JdbcTemplate實現上。通過JdbcTemplate獲取資

開源容器openshift學習筆記（3）：新增Image Stream

開篇之前如果沒有安裝openshift環境可以參考我的博文：centos7下安裝openshift 本系列部落格學習筆記參考《開源容器雲openshift》一書：下載連線：https://download.csdn.net/download/u012371097/10745382  

linux學習筆記（3）：vim及輸入輸出

vim的模式 命令模式：瀏覽檔案，臨時更改vim的工作模式，對文字批量處理 插入模式：對檔案內容進行編輯 退出模式：退出vim模式 vim命令模式 1.vim幫助 方法1： vim :help 方法2 vimtutor 2.vim工作引數設定 臨時設定 :set  引數資訊 :s

機器學習筆記（3）：線性代數回顧

目錄 1）Matrices and vectors 2）Addition and scalar multiplication 3）Matrix-vector multiplication 4）Matrix-matrix multiplication 5）Matrix multip

機器學習儲備（3）：似然函式例子解析

似然函式是個什麼函式，它的意義是什麼？它與概率相比，有什麼不同嗎？ 1、似然函式 似然函式是一種關於統計模型中的引數的函式，表示模型引數中的似然性。 給定輸出 x 時，關於引數 θ 的似然函式 L(θ|x)，在數值上它等於給定引數 θ 後變數 X 的概率： 這個是非常

深入學習Gremlin（3）：has條件過濾

第3期 Gremlin Steps： hasLabel(labels…​)、hasId(ids…​)、has(key, value)、

Spring學習筆記（一）：眼見為實，先上一個簡單例子

概述 所謂眼見為實，Spring雖然是一個輕量級的框架，但涉及眾多的概念，理解起來並不容易，因此，先參考資料寫一個簡單的Demo，從中洞見Spring的大體工作流程，為後面深入學習做鋪墊。 本文的Demo很簡單：模擬圖書資料訪問服務，即向資料庫中新增圖書資訊，涉及IBoo

Spring學習筆記（五）：Spring JDBC 框架及應用示例

JDBC 框架概述 在使用普通的 JDBC 資料庫時，就會很麻煩的寫不必要的程式碼來處理異常，開啟和關閉資料庫連線等。但 Spring JDBC 框架負責所有的低層細節，從開始開啟連線，準備和執行 SQL 語句，處理異常，處理事務，到最後關閉連線。 所以當從資料庫中獲取資

tensorflow學習筆記（3）：優化器optimizer

Ⅰ.class tf.train.Optimizer 優化器（optimizers）類的基類。這個類定義了在訓練模型的時候新增一個操作的API。你基本上不會直接使用這個類，但是你會用到他的子類比如GradientDescentOptimizer, AdagradOptimi

WPF學習筆記（3）：ListView根據內容自動調整列寬

DataGrid中，只要不設定DataGrid的寬度和列寬度，或者將寬度設定為Auto，那麼表格就會根據內容自動調整寬度，以顯示所有內容。但如果是ListView，按以上方法設定，卻達不到列寬自動調整的效果， 列寬在控制元件第一次載入的時候已經確定，之後不會隨著某列資料長度的增加和減少而改變列寬。找了很多方法

GIT學習筆記（3）：分支管理

tree 目錄樹 兩個 基本 使用 ranch ast strong 不同的 GIT學習筆記（3）：分支管理 何謂分支 GIT是如何存儲數據的 　　GIT不是存儲文件差異或者變化量，而是一系列文件的快照。在Git提交時，會保存一個提交(commit)對象，該對象包含一個指向

STM32學習筆記（3）：系統時鐘和SysTick定時器

2011年3月21日 系統時鐘和SysTick定時器 1.  STM32的時鐘系統 在STM32中，一共有5個時鐘源，分別是HSI、HSE、LSI、LSE、PLL （1）HSI是高速內部時鐘，RC振盪器，頻率為8MHz； （2） HSE是高速外部時鐘，可接石英/陶

Spring Cloud系列（3）：Spring Cloud Eureka

Spring Cloud Eureka 服務註冊與發現。在Spring Cloud體系中，Eureka角色是服務的註冊與發現。在裡面涉及到三個關鍵的角色：服務註冊中心，服務呼叫者，服務提供者。Eureka Servereureka server 是服務註冊中心，所有的服務都應

Spring學習筆記（四）：Spring AOP詳解

一.前言 二、什麼是 AOP？ AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。OOP引入封裝、繼承、多型等概念來建立一種

嚴蔚敏版資料結構學習筆記（3）：棧

棧是隻能在表尾進行插入和刪除的一種簡單一點的線性表。表尾端是棧頂(top)，表頭端是棧底(bottom)，不含元素的稱為空棧。因為我們只能對棧頂的元素進行插入和刪除操作，所以棧這個資料結構就是一個很有”原則”的結構，棧的修改是按照後進先出的原則進行的，也就是LI

深入學習Redis（3）：主從復制

狀態 默認 ping href 運行 dba 節點和 win 除了 原文:深入學習Redis（3）：主從復制前言 在前面的兩篇文章中，分別介紹了Redis的內存模型和Redis的持久化。 在Redis的持久化中曾提到，Redis高可用的方案包括持久化、主從復制（及讀寫分

【尚矽谷】spring學習筆記（1）：HelloWorld

1、安裝SPRING TOOL SUITE 這個 Eclipse 外掛。2、搭建spring開發環境，引入jar包。3、建立spring專案3.1、建立一個HelloWorld類public class HelloWorld { private String name;