盘锦市网站建设_网站建设公司_Photoshop_seo优化

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 步流程详解

1. 实例化 Bean

   • 容器调用 Bean 的无参构造方法，创建 Bean 对象；
   • 这是 Bean 生命周期的第一步，此时 Bean 的属性还未赋值。

2. Bean 属性赋值

   • 容器调用 Bean 的Set 方法，为 Bean 的属性注入值；
   • 依赖注入（DI）的核心步骤就在这里。

3. 初始化 Bean

   • 容器调用 Bean 的自定义初始化方法（需手动编写 + 配置）；
   • 此步骤可以执行 Bean 的初始化逻辑（如资源加载）。

4. 使用 Bean

   • Bean 对象创建完成，可被开发者从容器中获取并使用。

5. 销毁 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 后处理器的执行节点：

1. 实例化 Bean
2. Bean 属性赋值
3. 执行 Bean 后处理器的 before 方法（初始化前）
4. 初始化 Bean
5. 执行 Bean 后处理器的 after 方法（初始化后）
6. 使用 Bean
7. 销毁 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

五、关键注意事项

1. Bean 后处理器的作用范围：配置的BeanPostProcessor会作用于当前 Spring 配置文件中所有 Bean，而非单个 Bean；
2. 销毁方法的触发条件：只有关闭 Spring 容器时，才会触发destroy-method指定的销毁方法；
3. 强转容器的原因：ApplicationContext是父接口，无close()方法，需强转为子类（如ClassPathXmlApplicationContext）才能关闭容器。

总结

Spring 中 Bean 的生命周期，从 “5 步基础流程” 到 “7 步扩展流程”，核心是容器对 Bean 的全生命周期管理 + 开发者的自定义扩展能力。掌握这一流程，不仅能深入理解 Spring 的运行机制，也能为后续学习 AOP、事务管理等高级特性打下坚实基础