一文讀懂 Spring Bean 的生命周期-有解無憂

歡迎大家關注我的微信公眾號【老周聊架構】，Java后端主流技術堆疊的原理、原始碼分析、架構以及各種互聯網高并發、高性能、高可用的解決方案，

一、前言

今天我們來說一說 Spring Bean 的生命周期，小伙伴們應該在面試中經常遇到，這是正常現象，因為 Spring Bean 的生命周期是除了 IoC、AOP 幾個核心概念之外最重要概念，大家務必拿下，可 Spring 源代碼又比較復雜，跟著跟著就不知道跟到哪里去了，不太好拿下呀，這倒是真的，而且網上一上來就各種貼流程原始碼，對初學者來說是真的一臉懵逼，就像字都看的懂，但連在一塊就不知道意思了，太繞了，

本文老周試著講的通俗易懂些，讓更多的小伙伴們輕松的讀懂 Spring Bean 的生命周期，并有對它有繼續研究學習的想法，那我寫此文的目的也就達到了，

我們講 Spring Bean 的生命周期之前先來了解兩個概念：

1.1 什么是 Bean

我們來看下 Spring Framework 的官方檔案：

In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Otherwise, a bean is simply one of many objects in your application. Beans, and the dependencies among them, are reflected in the configuration metadata used by a container.

簡而言之，bean 是由 Spring IoC 容器實體化、組裝和管理的物件，

1.2 什么是 Spring Bean 的生命周期

對于普通的 Java 物件，當 new 的時候創建物件，然后該物件就能夠使用了，一旦該物件不再被使用，則由 Java 自動進行垃圾回收，

而 Spring 中的物件是 bean，bean 和普通的 Java 物件沒啥大的區別，只不過 Spring 不再自己去 new 物件了，而是由 IoC 容器去幫助我們實體化物件并且管理它，我們需要哪個物件，去問 IoC 容器要即可，IoC 其實就是解決物件之間的耦合問題，Spring Bean 的生命周期完全由容器控制，

二、Spring Bean 的生命周期

這里老周必須要提一下，這里我們說的 Spring Bean 的生命周期主要指的是 singleton bean，對于 prototype 的 bean ，Spring 在創建好交給使用者之后則不會再管理后續的生命周期，

我們也來復習下 Spring 中的 bean 的作用域有哪些?

singleton : 唯一 bean 實體，Spring 中的 bean 默認都是單例的，
prototype : 每次請求都會創建一個新的 bean 實體，
request : 每一次 HTTP 請求都會產生一個新的 bean，該 bean 僅在當前 HTTP request 內有效，
session : 每一次 HTTP 請求都會產生一個新的 bean，該 bean 僅在當前 HTTP session 內有效，
global-session：全域 session 作用域，僅僅在基于 Portlet 的 web 應用中才有意義，Spring5 已經沒有了，Portlet 是能夠生成語意代碼（例如：HTML）片段的小型 Java Web 插件，它們基于 portlet 容器，可以像 servlet 一樣處理 HTTP 請求，但是，與 servlet 不同，每個 portlet 都有不同的會話，

我們知道對于普通的 Java 物件來說，它們的生命周期就是：

實體化
該物件不再被使用時通過垃圾回識訓制進行回收

而對于 Spring Bean 的生命周期來說：

實體化 Instantiation
屬性賦值 Populate
初始化 Initialization
銷毀 Destruction

實體化 -> 屬性賦值 -> 初始化 -> 銷毀

只有四個步驟，這樣拆解的話是不是感覺也不難？不像其他人寫的那樣直接一上來就各種 BeanPostProcessor、BeanFactoryPostProcessor 全部懟進流程里去，別說讀者看著頭大，自己寫的可能短時間內還記得流程，隔個一段時間，你可能都不知道自己寫了個啥，

本來老周想通過 Bean 創建流程入口
AbstractApplicationContext#refresh() 方法的 finishBeanFactoryInitialization(beanFactory) 處帶大家跟一下原始碼，想了想還是不帶入過多的代碼進來，直接給到最終的主要邏輯，

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }

    if (instanceWrapper == null) {
    	// 實體化階段
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    ...

    Object exposedObject = bean;

    try {
    	// 屬性賦值階段
        this.populateBean(beanName, mbd, instanceWrapper);
        // 初始化階段
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable var18) {
        ...
    }

    ...
}

至于銷毀，是在容器關閉時呼叫的，詳見 ConfigurableApplicationContext#close()

是不是很清爽了？至于 BeanPostProcessor、BeanFactoryPostProcessor 以及其他的類，在老周看來，只不過是對主流程四個步驟的一系列擴展點而已，

三、Spring Bean 的生命周期的擴展點

Spring Bean 的生命周期的擴展點超級多，老周這里不可能全部列出來，只說核心的擴展點，這也就是為什么 Spring 的擴展性很好的原因，開了很多的口子，盡可能讓某個功能高內聚松耦合，用戶需要哪個功能就用哪個，而不是直接來一個大而全的東西，

3.1 Bean 自身的方法

比如建構式、getter/setter 以及 init-method 和 destory-method 所指定的方法等，也就對應著上文說的實體化 -> 屬性賦值 -> 初始化 -> 銷毀四個階段，

在這里插入圖片描述
3.2 容器級的方法（BeanPostProcessor 一系列介面）

主要是后處理器方法，比如下圖的 InstantiationAwareBeanPostProcessor、BeanPostProcessor 介面方法，這些介面的實作類是獨立于 Bean 的，并且會注冊到 Spring 容器中，在 Spring 容器創建任何 Bean 的時候，這些后處理器都會發生作用，

在這里插入圖片描述
3.2.1 InstantiationAwareBeanPostProcessor 原始碼分析

我們翻一下原始碼發現 InstantiationAwareBeanPostProcessor 是繼承了 BeanPostProcessor

在這里插入圖片描述

InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 呼叫點

Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
回傳值：如果回傳的不為null，那么后續的Bean的創建流程【實體化、初始化afterProperties】都不會執行，而是直接使用回傳的快捷Bean，此時的正常執行順序如下：
InstantiationAwareBeanPostProcessor介面中的postProcessBeforeInstantiation，在實體化之前呼叫，
BeanPostProcessor介面中的postProcessAfterInitialization，在實體化之后呼叫，

在這里插入圖片描述

總之，postProcessBeforeInstantiation 在 doCreateBean 之前呼叫，也就是在 bean 實體化之前呼叫的，英文原始碼注釋解釋道該方法的回傳值會替換原本的 Bean 作為代理，這也是 AOP 等功能實作的關鍵點，

InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 呼叫點

boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException
正常情況下在實體化之后在執行populateBean之前呼叫
回傳值：如果有指定的bean的時候回傳false，那么后續的屬性填充和屬性依賴注入【populateBean】將不會執行，同時后續的postProcessPropertyValues將不會執行,但是初始化和BeanPostProcessor的仍然會執行，

在這里插入圖片描述

public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
實體化之后呼叫，在方法applyPropertyValues【屬性填充】之前
回傳值：如果回傳null，那么將不會進行后續的屬性填充，比如依賴注入等，如果回傳的pvs額外的添加了屬性，那么后續會填充到該類對應的屬性中，
pvs：PropertyValues物件，用于封裝指定類的物件，簡單來說就是PropertyValue的集合，里面相當于以key-value形式存放類的屬性和值，
pds：PropertyDescriptor物件陣列，PropertyDescriptor相當于存盤類的屬性，不過可以呼叫set，get方法設定和獲取對應屬性的值，

在這里插入圖片描述
3.2.2 BeanPostProcessor 原始碼分析

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

在這里插入圖片描述
進入初始化介面：

在這里插入圖片描述
我們先來看

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

在這里插入圖片描述

首先獲取到所有的后置處理器 getBeanPostProcessors()
在 for 回圈中依次呼叫后置處理器的方法 processor.postProcessBeforeInitialization(result, beanName);
進入 postProcessBeforeInitialization 方法

org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization

在這里插入圖片描述

進入 invokeAwareInterfaces(bean); 方法，當前 bean 實作了 ApplicationContextAware 介面，

在這里插入圖片描述

ApplicationContextAwareProcessor#postProcessBeforeInitialization 首先判斷此 bean 是不是各種的Aware，如果是它列舉的那幾個 Aware 就獲取 Bean 工廠的權限，可以向容器中匯入相關的背景關系環境，目的是為了 Bean 實體能夠獲取到相關的背景關系，如果不是它列舉的幾個 Aware，那就呼叫 invokeAwareInterfaces(bean)，向容器中添加相關介面的背景關系環境，

3.3 工廠后處理器方法（BeanFactoryProcessor 一系列介面）

包括 AspectJWeavingEnabler、CustomAutowireConfigurer、ConfigurationClassPostProcessor 等，這些都是 Spring 框架中已經實作好的 BeanFactoryPostProcessor，用來實作某些特定的功能，

我們知道 Spring IoC 容器初始化的關鍵環節就在 org.springframework.context.support.AbstractApplicationContext#refresh 方法中，容器創建的主體流程都在這個方法里面，這個方法是真的重要！！！

對于工廠后處理器方法老周這里直接帶你看 invokeBeanFactoryPostProcessors(beanFactory); 方法，這個方法處理的是 BeanFactoryPostProcessor 介面的 Bean，呼叫方法如下：

在這里插入圖片描述
跟到最重要的方法里去，代碼雖長，但邏輯中規中矩，

BeanFactoryPostProcessor：一切處理 BeanFactory 的父介面
BeanDefinitionRegistryPostProcessor：實作了 BeanFactoryPostProcessor 介面的介面

在這里插入圖片描述
流程說明：

呼叫 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry(registry) 方法，引數 beanFactoryPostProcessors 傳入的優先處理掉，然后獲取容器注冊的，對于這些 Bean 按照 PriorityOrdered 介面、Ordered、沒有排序介面的實體分別進行處理，
呼叫 BeanFactoryPostProcessor#postProcessBeanFactory(beanFactory) 方法，備注：BeanDefinitionRegistryPostProcessor 屬于 BeanFactoryPostProcessor 子介面，先處理屬于 BeanDefinitionRegistryPostProcessor 介面實體的 postProcessBeanFactory(beanFactory) 方法，然后獲取容器注冊的，對于這些 Bean 按照 PriorityOrdered 介面、Ordered、沒有排序介面的實體分別進行處理，

3.4 Bean 級生命周期方法

可以理解為 Bean 類直接實作介面的方法，比如 BeanNameAware、BeanFactoryAware、ApplicationContextAware、InitializingBean、DisposableBean 等方法，這些方法只對當前 Bean 生效，

3.4.1 Aware 型別的介面

Aware 型別的介面的作用就是讓我們能夠拿到 Spring 容器中的一些資源，基本都能夠見名知意，Aware 之前的名字就是可以拿到什么資源，例如 BeanNameAware 可以拿到 BeanName，以此類推，呼叫時機需要注意：所有的 Aware 方法都是在初始化階段之前呼叫的，

Aware 介面眾多，這里同樣通過分類的方式幫助大家記憶，Aware 介面具體可以分為兩組，至于為什么這么分，詳見下面的原始碼分析，如下排列順序同樣也是 Aware 介面的執行順序，能夠見名知意的介面不再解釋，

Aware Group1

BeanNameAware
BeanClassLoaderAware
BeanFactoryAware

Aware Group2

EnvironmentAware
EmbeddedValueResolverAware
這個知道的人可能不多，實作該介面能夠獲取 Spring EL 決議器，用戶的自定義注解需要支持 SPEL 運算式的時候可以使用，非常方便，
ApplicationContextAware(ResourceLoaderAware/ApplicationEventPublisherAware/MessageSourceAware)
這幾個介面可能讓人有點懵，實際上這幾個介面可以一起記，其回傳值實質上都是當前的 ApplicationContext 物件，因為 ApplicationContext 是一個復合介面，如下：

Aware 呼叫時機原始碼分析

在這里插入圖片描述
可以看到并不是所有的 Aware 介面都使用同樣的方式呼叫，Bean××Aware 都是在代碼中直接呼叫的，而 ApplicationContext 相關的 Aware 都是通過 BeanPostProcessor#postProcessBeforeInitialization() 實作的，感興趣的可以自己看一下 ApplicationContextAwareProcessor 這個類的原始碼，就是判斷當前創建的 Bean 是否實作了相關的 Aware 方法，如果實作了會呼叫回呼方法將資源傳遞給 Bean，

BeanPostProcessor 的呼叫時機也能在這里體現，包圍住 invokeInitMethods 方法，也就說明了在初始化階段的前后執行，

關于 Aware 介面的執行順序，其實只需要記住第一組在第二組執行之前就行了，

3.4.2 生命周期介面

至于剩下的兩個生命周期介面就很簡單了，實體化和屬性賦值都是 Spring 幫助我們做的，能夠自己實作的有初始化和銷毀兩個生命周期階段，

InitializingBean 對應生命周期的初始化階段，在上面原始碼的 invokeInitMethods(beanName, wrappedBean, mbd);方法中呼叫，
有一點需要注意，因為 Aware 方法都是執行在初始化方法之前，所以可以在初始化方法中放心大膽的使用 Aware 介面獲取的資源，這也是我們自定義擴展 Spring 的常用方式，
除了實作 InitializingBean 介面之外還能通過注解或者 xml 配置的方式指定初始化方法，至于這幾種定義方式的呼叫順序其實沒有必要記，因為這幾個方法對應的都是同一個生命周期，只是實作方式不同，我們一般只采用其中一種方式，
DisposableBean 類似于 InitializingBean，對應生命周期的銷毀階段，以ConfigurableApplicationContext#close()方法作為入口，實作是通過回圈取所有實作了 DisposableBean 介面的 Bean 然后呼叫其 destroy() 方法，感興趣的可以自行跟一下原始碼，

3.5 Spring Bean 生命周期流程圖

在這里插入圖片描述

四、常用介面說明

4.1 BeanNameAware

該介面只有一個方法 setBeanName(String name)，用來獲取 bean 的 id 或者 name，

4.2 BeanFactoryAware

該介面只有一個方法 setBeanFactory(BeanFactory beanFactory)，用來獲取當前環境中的 BeanFactory，

4.3 ApplicationContextAware

該介面只有一個方法 setApplicationContext(ApplicationContext applicationContext)，用來獲取當前環境中的 ApplicationContext，

4.4 InitializingBean

該介面只有一個方法 afterPropertiesSet()，在屬性注入完成后呼叫，

4.5 DisposableBean

該介面只有一個方法 destroy()，在容器銷毀的時候呼叫，在用戶指定的 destroy-method 之前呼叫，

4.6 BeanPostProcessor

該介面有兩個方法：

postProcessBeforeInitialization(Object bean, String beanName)：在初始化之前呼叫此方法
postProcessAfterInitialization(Object bean, String beanName)：在初始化之后呼叫此方法

通過方法簽名我們可以知道，我們可以通過 beanName 來篩選出我們需要進行個性化定制的 bean，

4.7 InstantiationAwareBeanPostProcessor

該類是 BeanPostProcessor 的子介面，常用的有如下三個方法：

postProcessBeforeInstantiation(Class beanClass, String beanName)：在bean實體化之前呼叫
postProcessProperties(PropertyValues pvs, Object bean, String beanName)：在bean實體化之后、設定屬性前呼叫
postProcessAfterInstantiation(Class beanClass, String beanName)：在bean實體化之后呼叫

五、代碼演示

思路：創建一個類 UserBean ，讓其實作幾個特殊的介面，并分別在介面實作的構造器、介面方法中斷點，觀察執行緒呼叫堆疊，分析出 Bean 物件創建和管理關鍵點的觸發時機，

5.1 UserBean 類

@Component
public class UserBean implements InitializingBean, BeanNameAware, DisposableBean, ApplicationContextAware {
	private int id;

	private String name;

	public UserBean(int id, String name) {
		this.id = id;
		this.name = name;
		System.out.println("2. 呼叫建構式");
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
		System.out.println("5. 屬性注入 id");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
		System.out.println("5. 屬性注入 name");
	}

	@Override
	public void setBeanName(String name) {
		System.out.println("6. 呼叫 BeanNameAware.setBeanName() 方法");
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		UserBean userBean = (UserBean) applicationContext.getBean("userBean");
		System.out.println(userBean);
		System.out.println("7. 呼叫 BeanNameAware.setBeanName() 方法");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("9. 呼叫 InitializingBean.afterPropertiesSet() 方法");
	}

	public void myInit() {
		System.out.println("10. 呼叫 init-method 方法");
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("12. 呼叫 DisposableBean.destroy() 方法");
	}

	public void myDestroy() {
		System.out.println("13. 呼叫 destroy-method 方法");
	}

	@Override
	public String toString() {
		return "UserBean{" +
				"id=" + id +
				", name='" + name + '\'' +
				'}';
	}
}

5.2 InstantiationAwareBeanPostProcessor 介面實作類

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			System.out.println("1. 呼叫 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法");
		}
		return null;
	}

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			UserBean userBean = (UserBean) bean;
			System.out.println("3. 呼叫 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法");
			System.out.println(userBean);
		}
		return true;
	}

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			System.out.println("4. 呼叫 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法");
		}
		return null;
	}
}

5.3 BeanPostProcessor 介面實作類

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			System.out.println("8. 呼叫 BeanPostProcessor.postProcessBeforeInitialization() 方法");
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			System.out.println("11. 呼叫 BeanPostProcessor.postProcessAfterInitialization() 方法");
		}
		return bean;
	}
}

5.4 BeanFactoryPostProcessor 介面實作類

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("0. 呼叫 BeanFactoryPostProcessor.postProcessBeanFactory() 方法");
	}
}

5.5 applicationContext.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"
	   xsi:schemaLocation="
	    http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
">

	<bean class="com.riemann.test.MyInstantiationAwareBeanPostProcessor" />

	<bean id="userBean" class="com.riemann.test.UserBean" init-method="myInit" destroy-method="myDestroy">
		<!-- 建構式注入 -->
		<constructor-arg index="0" type="int">
			<value>1</value>
		</constructor-arg>
		<constructor-arg index="1" type="java.lang.String">
			<value>微信公眾號【老周聊架構】</value>
		</constructor-arg>

		<!-- setter方法注入 -->
		<property name="id" value="2"/>
		<property name="name" value="riemann"/>
	</bean>

	<bean class="com.riemann.test.MyBeanPostProcessor" />

	<bean class="com.riemann.test.MyBeanFactoryPostProcessor" />
	
</beans>

5.6 測驗類

public class BeanLifeCycleTest {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		UserBean user = (UserBean) applicationContext.getBean("userBean");
		((AbstractApplicationContext) applicationContext).close();
	}
}

5.7 控制臺結果列印

在這里插入圖片描述

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

標籤：java

上一篇：【死磕 Java Core】— 我同事一個 select 分頁陳述句查出來了 3000W 條資料

下一篇：01-課程準備作業