一、前言

今天我們來說一說 Spring Bean 的生命周期，小伙伴們應(yīng)該在面試中經(jīng)常遇到，這是正?，F(xiàn)象。因?yàn)?Spring Bean 的生命周期是除了 IoC、AOP 幾個(gè)核心概念之外最重要概念，大家務(wù)必拿下?？?Spring 源代碼又比較復(fù)雜，跟著跟著就不知道跟到哪里去了，不太好拿下呀。這倒是真的，而且網(wǎng)上一上來就各種貼流程源碼，對(duì)初學(xué)者來說是真的一臉懵逼，就像字都看的懂，但連在一塊就不知道意思了，太繞了。

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

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 容器實(shí)例化、組裝和管理的對(duì)象。

1.2 什么是 Spring Bean 的生命周期

對(duì)于普通的 Java 對(duì)象，當(dāng) new 的時(shí)候創(chuàng)建對(duì)象，然后該對(duì)象就能夠使用了。一旦該對(duì)象不再被使用，則由 Java 自動(dòng)進(jìn)行垃圾回收。

而 Spring 中的對(duì)象是 bean，bean 和普通的 Java 對(duì)象沒啥大的區(qū)別，只不過 Spring 不再自己去 new 對(duì)象了，而是由 IoC 容器去幫助我們實(shí)例化對(duì)象并且管理它，我們需要哪個(gè)對(duì)象，去問 IoC 容器要即可。IoC 其實(shí)就是解決對(duì)象之間的耦合問題，Spring Bean 的生命周期完全由容器控制。

二、Spring Bean 的生命周期

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

我們也來復(fù)習(xí)下 Spring 中的 bean 的作用域有哪些?

singleton : 唯一 bean 實(shí)例，Spring 中的 bean 默認(rèn)都是單例的。
prototype : 每次請(qǐng)求都會(huì)創(chuàng)建一個(gè)新的 bean 實(shí)例。
request : 每一次 HTTP 請(qǐng)求都會(huì)產(chǎn)生一個(gè)新的 bean，該 bean 僅在當(dāng)前 HTTP request 內(nèi)有效。
session : 每一次 HTTP 請(qǐng)求都會(huì)產(chǎn)生一個(gè)新的 bean，該 bean 僅在當(dāng)前 HTTP session 內(nèi)有效。
global-session： 全局 session 作用域，僅僅在基于 Portlet 的 web 應(yīng)用中才有意義，Spring5 已經(jīng)沒有了。Portlet 是能夠生成語義代碼（例如：HTML）片段的小型 Java Web 插件。它們基于 portlet 容器，可以像 servlet 一樣處理 HTTP 請(qǐng)求。但是，與 servlet 不同，每個(gè) portlet 都有不同的會(huì)話。

我們知道對(duì)于普通的 Java 對(duì)象來說，它們的生命周期就是：

• 實(shí)例化
• 該對(duì)象不再被使用時(shí)通過垃圾回收機(jī)制進(jìn)行回收

而對(duì)于 Spring Bean 的生命周期來說：

• 實(shí)例化 Instantiation
• 屬性賦值 Populate
• 初始化 Initialization
• 銷毀 Destruction

實(shí)例化 -> 屬性賦值 -> 初始化 -> 銷毀

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

本來小編想通過 Bean 創(chuàng)建流程入口

AbstractApplicationContext#refresh() 方法的 finishBeanFactoryInitialization(beanFactory) 處帶大家跟一下源碼，想了想還是不帶入過多的代碼進(jìn)來，直接給到最終的主要邏輯。

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) {
    	// 實(shí)例化階段
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    ...

    Object exposedObject = bean;

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

    ...
}

至于銷毀，是在容器關(guān)閉時(shí)調(diào)用的，詳見 ConfigurableApplicationContext#close()

是不是很清爽了？至于 BeanPostProcessor、BeanFactoryPostProcessor 以及其他的類，在老周看來，只不過是對(duì)主流程四個(gè)步驟的一系列擴(kuò)展點(diǎn)而已。

三、Spring Bean 的生命周期的擴(kuò)展點(diǎn)

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

3.1 Bean 自身的方法

比如構(gòu)造函數(shù)、getter/setter 以及 init-method 和 destory-method 所指定的方法等，也就對(duì)應(yīng)著上文說的實(shí)例化 -> 屬性賦值 -> 初始化 -> 銷毀四個(gè)階段。

3.2 容器級(jí)的方法（BeanPostProcessor 一系列接口）

主要是后處理器方法，比如下圖的 InstantiationAwareBeanPostProcessor、BeanPostProcessor 接口方法。這些接口的實(shí)現(xiàn)類是獨(dú)立于 Bean 的，并且會(huì)注冊(cè)到 Spring 容器中。在 Spring 容器創(chuàng)建任何 Bean 的時(shí)候，這些后處理器都會(huì)發(fā)生作用。

3.2.1 InstantiationAwareBeanPostProcessor 源碼分析

我們翻一下源碼發(fā)現(xiàn) InstantiationAwareBeanPostProcessor 是繼承了 BeanPostProcessor

• InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 調(diào)用點(diǎn)

 Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
返回值：如果返回的不為null，那么后續(xù)的Bean的創(chuàng)建流程【實(shí)例化、初始化afterProperties】都不會(huì)執(zhí)行，而是直接使用返回的快捷Bean，此時(shí)的正常執(zhí)行順序如下：
InstantiationAwareBeanPostProcessor接口中的postProcessBeforeInstantiation，在實(shí)例化之前調(diào)用。
BeanPostProcessor接口中的postProcessAfterInitialization，在實(shí)例化之后調(diào)用。

總之，postProcessBeforeInstantiation 在 doCreateBean 之前調(diào)用，也就是在 bean 實(shí)例化之前調(diào)用的，英文源碼注釋解釋道該方法的返回值會(huì)替換原本的 Bean 作為代理，這也是 AOP 等功能實(shí)現(xiàn)的關(guān)鍵點(diǎn)。

• InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 調(diào)用點(diǎn)

 boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException
正常情況下在實(shí)例化之后在執(zhí)行populateBean之前調(diào)用
返回值：如果有指定的bean的時(shí)候返回false，那么后續(xù)的屬性填充和屬性依賴注入【populateBean】將不會(huì)執(zhí)行，同時(shí)后續(xù)的postProcessPropertyValues將不會(huì)執(zhí)行,但是初始化和BeanPostProcessor的仍然會(huì)執(zhí)行。

 public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
實(shí)例化之后調(diào)用，在方法applyPropertyValues【屬性填充】之前
返回值：如果返回null，那么將不會(huì)進(jìn)行后續(xù)的屬性填充，比如依賴注入等，如果返回的pvs額外的添加了屬性，那么后續(xù)會(huì)填充到該類對(duì)應(yīng)的屬性中。
pvs：PropertyValues對(duì)象，用于封裝指定類的對(duì)象，簡單來說就是PropertyValue的集合，里面相當(dāng)于以key-value形式存放類的屬性和值。
pds：PropertyDescriptor對(duì)象數(shù)組，PropertyDescriptor相當(dāng)于存儲(chǔ)類的屬性，不過可以調(diào)用set，get方法設(shè)置和獲取對(duì)應(yīng)屬性的值。

3.2.2 BeanPostProcessor 源碼分析

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

進(jìn)入初始化接口：

我們先來看

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

•  首先獲取到所有的后置處理器 getBeanPostProcessors()
• 在 for 循環(huán)中依次調(diào)用后置處理器的方法 processor.postProcessBeforeInitialization(result, beanName);
• 進(jìn)入 postProcessBeforeInitialization 方法

 org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization

進(jìn)入 invokeAwareInterfaces(bean); 方法，當(dāng)前 bean 實(shí)現(xiàn)了 ApplicationContextAware 接口。

• ApplicationContextAwareProcessor#postProcessBeforeInitialization 首先判斷此 bean 是不是各種的Aware，如果是它列舉的那幾個(gè) Aware 就獲取 Bean 工廠的權(quán)限，可以向容器中導(dǎo)入相關(guān)的上下文環(huán)境，目的是為了 Bean 實(shí)例能夠獲取到相關(guān)的上下文，如果不是它列舉的幾個(gè) Aware，那就調(diào)用 invokeAwareInterfaces(bean)，向容器中添加相關(guān)接口的上下文環(huán)境。

 3.3 工廠后處理器方法（BeanFactoryProcessor 一系列接口）

包括 AspectJWeavingEnabler、CustomAutowireConfigurer、ConfigurationClassPostProcessor 等。這些都是 Spring 框架中已經(jīng)實(shí)現(xiàn)好的 BeanFactoryPostProcessor，用來實(shí)現(xiàn)某些特定的功能。

我們知道 Spring IoC 容器初始化的關(guān)鍵環(huán)節(jié)就在 org.springframework.context.support.AbstractApplicationContext#refresh 方法中 ，容器創(chuàng)建的主體流程都在這個(gè)方法里面，這個(gè)方法是真的重要?。。?/strong>

@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. 調(diào)用構(gòu)造函數(shù)");
	}

	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. 調(diào)用 BeanNameAware.setBeanName() 方法");
	}

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

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("9. 調(diào)用 InitializingBean.afterPropertiesSet() 方法");
	}

	public void myInit() {
		System.out.println("10. 調(diào)用 init-method 方法");
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("12. 調(diào)用 DisposableBean.destroy() 方法");
	}

	public void myDestroy() {
		System.out.println("13. 調(diào)用 destroy-method 方法");
	}

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

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userBean".equals(beanName)) {
			System.out.println("1. 調(diào)用 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. 調(diào)用 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. 調(diào)用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法");
		}
		return null;
	}
}

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

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

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("0. 調(diào)用 BeanFactoryPostProcessor.postProcessBeanFactory() 方法");
	}
}

<?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">
		<!-- 構(gòu)造函數(shù)注入 -->
		<constructor-arg index="0" type="int">
			<value>1</value>
		</constructor-arg>
		<constructor-arg index="1" type="java.lang.String">
			<value>微信公眾號(hào)【老周聊架構(gòu)】</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>

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();
	}
}