Spring中bean生命周期过程是如何通过代码实现的？
摘要：今天我们编写一个简单的demo来分析一下spring中整个bean的生命周期 编写Demo 1. 首先我们定义一个BeanFactoryProcessor的类，目的是为了看出PostProcessBeanFactory接口被调用的时间点 p
今天我们编写一个简单的demo来分析一下spring中整个bean的生命周期
编写Demo
1. 首先我们定义一个BeanFactoryProcessor的类，目的是为了看出PostProcessBeanFactory接口被调用的时间点
package cn.sue.spring.test.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/**
* <p>
*
* </p>
*
* @author Sue
* @className MyBeanFactoryPostProcessor
* @create 2023/4/25
**/
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
super();
System.out.println("【BeanFactoryPostProcessor】实现类的构造函数");
}
// 允许我们在工厂里所有的bean被加载进来后但是还没初始化前，对所有bean的属性进行修改也可以add属性值，该操作在对应bean的构造函数执行前
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0) throws BeansException {
System.out.println("BeanFactoryPostProcessor.postProcessBeanFactory()，来自MyBeanFactoryPostProcessor");
//获取到Spring中所有的beanName
String[] beanStr = arg0.getBeanDefinitionNames();
//循环打印
for (String beanName : beanStr) {
System.out.print("已加载的bean name:" + beanName + ";" + "\n");
}
System.out.println();
}
}
2. 接着再写一个实现了BeanPostProcessor的类，目的是为了看出bean初始化前后的时间点
package cn.sue.spring.test.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* <p>
*
* </p>
*
* @author Sue
* @className MyBeanPostProcessor
* @create 2023/4/25
**/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("BeanPostProcessor{}实现类的构造函数");
}
// 实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的业务
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1)
throws BeansException {
if (arg0.getClass() == TestBeanA.class || arg0.getClass() == TestBeanB.class) {
System.out
.println("BeanPostProcessor.postProcessAfterInitialization() 来自MyBeanPostProcessor，beanName:" + arg1);
}
return arg0;
}
// 实例化、依赖注入、初始化后完成一些定制的业务
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1)
throws BeansException {
if (arg0.getClass() == TestBeanA.class || arg0.getClass() == TestBeanB.class) {
System.out
.println("BeanPostProcessor.postProcessBeforeInitialization() 来自MyBeanPostProcessor，beanName:" + arg1);
}
return arg0;
}
}
3. 再给出一个继承了InstantiationAwareBeanPostProcessorAdapter的子类，目的是为了看出postProcessBeforeInitialization、postProcessAfterInitialization、postProcessPropertyValues被调用的时间点
package cn.sue.spring.test.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;
import java.beans.PropertyDescriptor;
/**
* <p>
*
* </p>
*
* @author Sue
* @className MyInstantiationAwareBeanPostProcessor
* @create 2023/4/25
**/
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
public MyInstantiationAwareBeanPostProcessor() {
super();
System.out
.println("InstantiationAwareBeanPostProcessorAdapter{}实现类MyInstantiationAwareBeanPostProcessor{}的构造函数");
}
// 接口方法、实例化Bean之前调用
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
System.out
.println("InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);
}
return bean;
}
// 接口方法、实例化Bean之后调用
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
System.out
.println("InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);
}
return bean;
}
// 接口方法、设置某个属性时调用
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
System.out
.println("InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 来自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);
}
return pvs;
}
}
4. 再定义一个Bean，它使用applicationContext.xml进行注册并实现了BeanFactoryAware, BeanNameAware,InitializingBean,DisposableBean四个接口类，目的是为了清晰的看出以下好几个接口被调用的时间点
package cn.sue.spring.test.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import javax.annotation.PostConstruct;
public class TestBeanA implements BeanFactoryAware, BeanNameAware,
InitializingBean, DisposableBean {
private String name;
private String address;
private int phone;
private BeanFactory beanFactory;
private String beanName;
@PostConstruct
public void init() {
System.out.println("TestBeanA{} @PostConstruct");
}
public TestBeanA() {
System.out.println("TestBeanA{} 默认构造函数");
}
public TestBeanA(String name) {
System.out.println("TestBeanA{} 有参构造函数");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getPhone() {
return phone;
}
public void setPhone(int phone) {
this.phone = phone;
}
@Override
public String toString() {
return "TestBeanA [address=" + address + ", name=" + name + ", phone="
+ phone + "]";
}
// 这是BeanFactoryAware接口方法
@Override
public void setBeanFactory(BeanFactory arg0) throws BeansException {
System.out
.println("BeanFactoryAware.setBeanFactory() 来自TestBeanA");
this.beanFactory = arg0;
}
// 这是BeanNameAware接口方法
@Override
public void setBeanName(String arg0) {
System.out.println("BeanNameAware.setBeanName() 来自TestBeanA");
this.beanName = arg0;
}
// 这是InitializingBean接口方法
@Override
public void afterPropertiesSet() throws Exception {
System.out
.println("InitializingBean.afterPropertiesSet() 来自TestBeanA");
}
// 这是DiposibleBean接口方法
@Override
public void destroy() throws Exception {
System.out.println("DiposibleBean.destory() 来自TestBeanA");
}
// 通过<bean>的init-method属性指定的初始化方法
public void myInit() {
System.out.println("TestBeanA.myInit()");
}
// 通过<bean>的destroy-method属性指定的初始化方法
public void myDestory() {
System.out.println("TestBeanA.destroy-method()");
}
}
5. 最后，再定义一个TestBeanB，它的作用比较简单，为了看出内部数据成员有其他容器Bean的时候Spring是如何加载bean的
package cn.sue.spring.test.lifecycle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class TestBeanB {
@Autowired
private TestBeanA testBeanA;
public TestBeanB() {
System.out.println("TestBeanB{} 默认构造器");
}
}
6.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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="cn.sue.spring.test.lifecycle" >
</context:component-scan>
<!-- <bean id="user" class="cn.sue.spring.test.core.UserService"></bean>-->
<bean id="testBeanA" class="cn.sue.spring.test.lifecycle.TestBeanA" init-method="myInit" destroy-method="myDestory">
<property name="name" value="Sue.test"/>
</bean>
</beans>
7.加载容器进行测试
@Test
public void testLifeCycle() {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml");
classPathXmlApplicationContext.destroy();
}
查看结果并分析
首先从
BeanFactoryPostProcessor{}实现类MyBeanFactoryPostProcessor{}的构造函数
BeanFactoryPostProcessor.postProcessBeanFactory()，来自MyBeanFactoryPostProcessor
BeanPostProcessor{}实现类MyBeanPostProcessor{}的构造函数
InstantiationAwareBeanPostProcessorAdapter{}实现类MyInstantiationAwareBeanPostProcessor{}的构造函数
可以看出执行顺序是：
调用postProcessBeanFactory实现类的构造函数
BeanFactoryPostProcessor是bean工厂的处理器
调用postProcessBeanFactory实现类的postProcessBeanFactory实现函数
postProcessBeanFactory函数允许我们在工厂里所有的bean被加载进来后但是还没初始化前，对所有bean的属性进行修改也可以add属性值
调用BeanPostProcessor实现类的构造函数
完成bean实例化、配置以及其他初始化方法前后要添加一些自己逻辑处理则要实现接口BeanPostProcessor
调用InstantiationAwareBeanPostProcessorAdapter实现类的构造函数
适配器类，基类是BeanPostProcessor的实现类
再从
TestBeanB{} 默认构造器
InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB
可以看到，此处spring容器先扫描到了TestBeanB，因此调用顺序是
TestBeanB的默认构造器【无参构造器】
调用InstantiationAwareBeanPostProcessorAdapter实现类的postProcessPropertyValues接口
postProcessPropertyValues在接口方法、设置某个属性时调用，通过实验看到实例化一个Bean的时候也会调用该接口方法
之后实例化TestBeanB的时候发现内部注入了TestBeanA，因此Spring转而实例化TestBeanA。
接下来看到的是TestBeanA的实例化过程中调用的顺序
TestBeanA{} 默认构造函数
InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA
BeanNameAware.setBeanName() 来自TestBeanA
BeanFactoryAware.setBeanFactory() 来自TestBeanA
BeanPostProcessor.postProcessBeforeInitialization() 来自MyBeanPostProcessor，beanName:testBeanA
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA
TestBeanA{} @PostConstruct
InitializingBean.afterPropertiesSet() 来自TestBeanA
TestBeanA.myInit()
BeanPostProcessor.postProcessAfterInitialization() 来自MyBeanPostProcessor，beanName:testBeanA
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA
调用了TestBeanA的默认构造器
调用InstantiationAwareBeanPostProcessorAdapter实现类的postProcessPropertyValues接口
调用BeanNameAware的setBeanName接口
可以从源码看到TestBeanA实现了接口BeanNameAware
调用BeanFactoryAware的setBeanFactory接口
可以从源码看到TestBeanA实现了接口BeanFactoryAware
调用BeanPostProcessor的postProcessBeforeInitialization接口
调用InstantiationAwareBeanPostProcessorAdapter的postProcessBeforeInitialization接口
调用TestBeanA中注解了@PostConstruct的函数
调用了InitializingBean的afterPropertiesSet接口
可以从源码看到TestBeanA实现了接口InitializingBean
调用了TestBeanA的myInit接口
可以看到该init-method接口是在applicationContext中init-method配置上的
调用BeanPostProcessor实现类的postProcessAfterInitialization接口
调用InstantiationAwareBeanPostProcessorAdapter子类的postProcessAfterInitialization接口
等TestBeanA实例化结束后，则继续TestBeanB的实例化路程
BeanPostProcessor.postProcessBeforeInitialization() 来自MyBeanPostProcessor，beanName:testBeanB
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB
BeanPostProcessor.postProcessAfterInitialization() 来自MyBeanPostProcessor，beanName:testBeanB
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 来自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB
调用BeanPostProcessor实现类的postProcessBeforeInitialization接口
调用InstantiationAwareBeanPostProcessorAdapter子类的postProcessBeforeInitialization接口
调用BeanPostProcessor实现类的postProcessAfterInitialization接口
调用InstantiationAwareBeanPostProcessorAdapter子类的postProcessAfterInitialization接口
最后
DiposibleBean.destory() 来自TestBeanA
TestBeanA.destroy-method()
调用DiposibleBean实现类的destory接口
TestBeanA实现了DiposibleBean接口，实现了destroy接口
调用TestBeanA的myDestory函数
可以看到该myDestory接口是在applicationContext中destroy-method配置上的。
最终总结
【超重点，面试回答模板】
如果有bean实现了BeanFactoryPostProcessor接口类，则会实例化该bean，并且调用默认构造器，然后调用postProcessBeanFactory接口
如果有bean实现了BeanPostProcessor接口类，则会先实例化该bean，同样调用默认构造器
如果有bean继承了InstantiationAwareBeanPostProcessorAdapter类，则会先实例化该bean，同样调用默认构造器
之后真正进入一个bean的生命周期过程
先调用bean的默认构造函数
如果有bean继承了InstantiationAwareBeanPostProcessorAdapter类，此刻会调用postProcessPropertyValues函数
如果这个bean已经实现了BeanNameAware接口，会调用它实现的setBeanName方法，此处传递的就是applicationContext.xml配置文件中Bean的id值
如果这个bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory，传递的是Spring工厂自身
如果存在其他bean实现了BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术；
如果存在其他bean继承了InstantiationAwareBeanPostProcessorAdapter类，则会调用postProcessBeforeInitialization接口
如果这个bean中有函数加了@PostConstruct注解，则该函数会在此刻被调用
如果这个bean实现了InitializingBean接口重写了afterPropertiesSet方法，该方法会在此刻被调用
如果这个bean在Spring配置文件中配置了init-method属性，则会自动调用其配置的初始化方法。
如果存在其他bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法
如果存在其他bean继承了InstantiationAwareBeanPostProcessorAdapter类，则会调用postProcessAfterInitialization接口
走到这一步以后就可以应用这个Bean了，而这个Bean是一个Singleton的，虽然在Spring配置文件中也可以配置非Singleton，这里不做赘述。
走入销毁阶段
当bean不再需要时，会经过清理阶段，如果这个bean实现了DisposableBean接口，会调用其实现的destroy()方法；
如果这个bean的applicationContext.xml配置中配置了destroy-method属性，会自动调用其配置的销毁方法。
本案例demo下载地址suyang320/spring_study (github.com)