Spring 中 Bean 的生命周期：从 5 步到 7 步的深度解析
在 Spring 框架中，Bean 是核心组件之一，而理解 Bean 的生命周期是掌握 Spring 容器管理机制的关键。本文将从概念、作用、5 步基础流程、7 步扩展流程四个维度，结合代码示例，带你彻底搞懂 Spring 中 Bean 的生命周期。
一、什么是 Bean 的生命周期？
Spring 本质是一个Bean 对象的工厂 ，负责 Bean 的创建、管理、销毁等全流程。所谓 "Bean 的生命周期"，就是指：Bean 对象从创建开始，到最终被容器销毁的整个过程。
我们需要关注的核心问题：
- 什么时候创建 Bean 对象？
- Bean 创建 / 销毁的前后会调用哪些方法？
- 如何在特定节点插入自定义逻辑？
二、为什么要了解 Bean 的生命周期？
生命周期的本质是 **"时间节点" 与 "方法调用" 的对应关系 **------ 即 "在哪个时间点，容器会调用哪个类的哪个方法"。
了解生命周期的价值：
- 明确 Bean 的执行流程，精准定位代码的编写位置；
- 可以在特定时间节点（如初始化前 / 后）插入自定义逻辑（比如日志打印、资源初始化 / 释放）；
- 是理解 Spring 高级特性（如 AOP、BeanPostProcessor）的基础。
三、Bean 的生命周期之 5 步基础流程
Spring 中 Bean 的生命周期可以先粗略划分为5 个核心步骤 ，对应AbstractAutowireCapableBeanFactory类的doCreateBean()方法（Spring 源码核心逻辑）。
5 步流程详解
-
实例化 Bean
- 容器调用 Bean 的无参构造方法，创建 Bean 对象；
- 这是 Bean 生命周期的第一步，此时 Bean 的属性还未赋值。
-
Bean 属性赋值
- 容器调用 Bean 的Set 方法，为 Bean 的属性注入值；
- 依赖注入（DI）的核心步骤就在这里。
-
初始化 Bean
- 容器调用 Bean 的自定义初始化方法（需手动编写 + 配置）；
- 此步骤可以执行 Bean 的初始化逻辑（如资源加载）。
-
使用 Bean
- Bean 对象创建完成，可被开发者从容器中获取并使用。
-
销毁 Bean
- 容器关闭时，调用 Bean 的自定义销毁方法（需手动编写 + 配置）；
- 此步骤可以执行资源释放逻辑（如关闭连接）。
5 步流程代码示例
1. 定义 User 类（包含生命周期各阶段方法）
java
运行
public class User {
private String name;
// 1. 实例化Bean：无参构造方法
public User() {
System.out.println("1. 实例化Bean");
}
// 2. Bean属性赋值：Set方法
public void setName(String name) {
this.name = name;
System.out.println("2. Bean属性赋值");
}
// 3. 初始化Bean：自定义初始化方法（需配置）
public void initBean() {
System.out.println("3. 初始化Bean");
}
// 5. 销毁Bean：自定义销毁方法（需配置）
public void destroyBean() {
System.out.println("5. 销毁Bean");
}
}2. Spring 配置文件（spring.xml）
xml
<!-- 配置User Bean，并指定初始化/销毁方法 -->
<bean id="user" class="com.powernode.spring6.bean.User"
init-method="initBean" destroy-method="destroyBean">
<!-- 属性赋值 -->
<property name="name" value="zhangsan"/>
</bean>3. 测试类（验证 5 步流程）
java
运行
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanLifecycleTest {
@Test
public void testLifecycleFive() {
// 加载配置文件，启动容器（触发Bean的创建）
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
// 4. 使用Bean
User user = applicationContext.getBean("user", User.class);
System.out.println("4. 使用Bean：" + user);
// 关闭容器（触发Bean的销毁）
// 注意：ApplicationContext父类无close方法，需强转为子类ClassPathXmlApplicationContext
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close();
}
}4. 运行结果
plaintext
1. 实例化Bean
2. Bean属性赋值
3. 初始化Bean
4. 使用Bean：com.powernode.spring6.bean.User@xxxxxx
5. 销毁Bean四、Bean 的生命周期之 7 步扩展流程
5 步流程满足了基础需求，但如果想在初始化前后插入自定义逻辑 ，需要引入BeanPostProcessor（Bean 后处理器），从而扩展为 7 步流程。
什么是 BeanPostProcessor？
BeanPostProcessor是 Spring 提供的一个扩展接口，被称为 "Bean 后处理器"：
- 它本身是一个特殊的 Bean，被容器管理；
- 作用是在所有 Bean 的初始化前后，统一执行自定义逻辑；
- 需重写
postProcessBeforeInitialization（初始化前）和postProcessAfterInitialization（初始化后）两个方法。
7 步流程详解
在 5 步流程的基础上，插入 2 个 Bean 后处理器的执行节点：
- 实例化 Bean
- Bean 属性赋值
- 执行 Bean 后处理器的 before 方法（初始化前）
- 初始化 Bean
- 执行 Bean 后处理器的 after 方法（初始化后）
- 使用 Bean
- 销毁 Bean
7 步流程代码示例
1. 定义 Bean 后处理器（实现 BeanPostProcessor 接口）
java
运行
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class LogBeanPostProcessor implements BeanPostProcessor {
// 初始化前执行
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("3. 执行Bean后处理器的before方法（bean对象：" + bean + "，bean名称：" + beanName + "）");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
// 初始化后执行
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("5. 执行Bean后处理器的after方法（bean对象：" + bean + "，bean名称：" + beanName + "）");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}2. 配置 Bean 后处理器（spring.xml）
xml
<!-- 配置Bean后处理器：作用于当前配置文件中所有Bean -->
<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>
<!-- 原User Bean配置 -->
<bean id="user" class="com.powernode.spring6.bean.User"
init-method="initBean" destroy-method="destroyBean">
<property name="name" value="zhangsan"/>
</bean>
3. 运行结果（7 步流程）
plaintext
1. 实例化Bean
2. Bean属性赋值
3. 执行Bean后处理器的before方法（bean对象：com.powernode.spring6.bean.User@xxxxxx，bean名称：user）
4. 初始化Bean
5. 执行Bean后处理器的after方法（bean对象：com.powernode.spring6.bean.User@xxxxxx，bean名称：user）
6. 使用Bean：com.powernode.spring6.bean.User@xxxxxx
7. 销毁Bean五、关键注意事项
- Bean 后处理器的作用范围 ：配置的
BeanPostProcessor会作用于当前 Spring 配置文件中所有 Bean，而非单个 Bean； - 销毁方法的触发条件 ：只有关闭 Spring 容器时，才会触发
destroy-method指定的销毁方法； - 强转容器的原因 ：
ApplicationContext是父接口，无close()方法，需强转为子类（如ClassPathXmlApplicationContext）才能关闭容器。
总结
Spring 中 Bean 的生命周期，从 "5 步基础流程" 到 "7 步扩展流程"，核心是容器对 Bean 的全生命周期管理 + 开发者的自定义扩展能力。掌握这一流程，不仅能深入理解 Spring 的运行机制，也能为后续学习 AOP、事务管理等高级特性打下坚实基础