发帖
雷达卡
在 Spring 框架的庞大生态中，Bean 的生命周期如同一条贯穿始终的主线，深刻影响着整个 IoC（控制反转）容器的运作机制。它不仅是理解 Spring 核心原理的关键切入点，也在实际开发、性能调优与问题排查中扮演着至关重要的角色。尤其在技术面试中，Spring Bean 生命周期常常作为考察候选人掌握框架深度的重要题目，从基础流程到源码实现，层层递进，成为区分能力高低的“试金石”。接下来，我们将系统性地剖析这一核心机制，帮助你在开发与面试中游刃有余，轻松应对各类相关挑战。
什么是 Bean？
根据 Spring Framework 官方文档的说明，Bean 是指由 Spring IoC 容器负责创建、装配和管理的对象。换句话说，应用中的各类组件——如服务层对象、数据访问对象等——一旦被注册为 Bean，就交由 Spring 容器统一管控。容器不仅完成实例的构建，还处理其依赖注入和生命周期维护。
举个例子，当我们定义一个业务服务类时，可以将其声明为 Bean，Spring 容器会自动创建其实例，并将所需的 DAO 等依赖项注入其中，从而实现组件间的松耦合协作。这种模式类似于一个智能化的生产流水线：Spring IoC 容器是总控中心，而每一个 Bean 就是流水线上被精确制造并组装的零部件，最终共同构成完整的系统功能。
Spring Bean 生命周期概述
要深入理解 Spring Bean 的生命周期，有必要先回顾普通 Java 对象的生命周期，以便形成对比，凸显 Spring 管理下的特殊性。
普通 Java 对象的生命周期
在标准 Java 编程中，对象的生命周期较为简单。当使用 new 关键字创建对象时，JVM 会在堆内存中为其分配空间，并调用相应的构造函数进行初始化。例如：
newpublic class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; System.out.println("Person对象被创建，姓名：" + name + "，年龄：" + age); } public void sayHello() { System.out.println("大家好，我是" + name + "，今年" + age + "岁。"); } } public class Main { public static void main(String[] args) { Person person = new Person("张三", 25); person.sayHello(); } }new Person("张三", 25)Person上述代码通过 new UserService() 创建了一个 UserService 实例，对象随即进入可用状态，可被调用其方法执行业务逻辑，比如：
person.sayHello()当该对象不再被任何引用指向时，便成为垃圾回收的候选对象，由 JVM 的垃圾回收器（GC）在适当时候回收其占用的内存，生命周期就此终结。
Spring Bean 的生命周期特点
相比之下，Spring 中的 Bean 生命周期由容器全权掌控，过程更为复杂且具备扩展能力。整体上可分为四个主要阶段：实例化、属性赋值、初始化和销毁。
在实例化阶段，Spring 容器依据配置元信息，利用反射技术生成 Bean 实例；随后进入属性赋值阶段，容器将其他 Bean 或配置值注入当前实例，完成依赖装配；接着是初始化阶段，允许开发者通过自定义方法或接口回调执行特定逻辑，如连接池启动、缓存预热等；最后，当容器关闭时，单例 Bean 会经历销毁流程，执行清理操作，释放资源。
值得注意的是，Spring 支持多种作用域，但本文聚焦于最常用的单例（singleton）模式。在此模式下，Bean 实例唯一且与容器共存亡，具有广泛的适用性和代表性。
InitializingBeanafterPropertiesSetSpring Bean 生命周期详细流程解析
1. 实例化（Instantiation）
这是生命周期的第一步，即创建 Bean 对象的原始实例。Spring 提供了多种实例化方式，主要包括构造函数实例化和工厂方法实例化。
构造函数实例化是最常见的方式。容器通过调用类的构造函数来完成对象创建。例如，存在如下服务类：
UserServicepublic class UserService { public UserService() { System.out.println("UserService被实例化"); } }若采用 XML 配置方式，可通过以下方式声明 Bean：
<bean id="userService" class="com.example.demo.service.UserService"/>当容器启动并加载配置时，会触发 UserService 的无参构造函数，输出“UserService 被实例化”，完成实例创建。
另一种方式是工厂方法实例化，适用于需要复杂逻辑创建对象的场景。假设我们有一个工厂类 UserServiceFactory：
UserServiceFactorypublic class UserServiceFactory { public static UserService createUserService() { System.out.println("通过工厂方法创建UserService"); return new UserService(); } }可以在配置文件中指定工厂类及其创建方法：
factory-method<bean id="userService" class="com.example.demo.factory.UserServiceFactory" factory-method="createUserService"/>此时，Spring 容器将调用 createInstance() 方法获取 UserService 实例，控制台输出“通过工厂方法创建 UserService”。
createUserService4.2 属性赋值（Population）
在属性赋值阶段，Spring 利用反射机制完成依赖注入，为使用如
@Autowired、
@Value等注解标注的字段进行赋值。Spring 支持多种注入方式，包括构造器注入、Setter 方法注入以及字段注入。
以构造器注入为例，假设存在如下依赖关系：
UserService依赖于
UserRepository，其代码结构如下：
public class UserRepository { public UserRepository() { System.out.println("UserRepository被实例化"); } } public class UserService { private final UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository = userRepository; System.out.println("UserService被实例化，注入UserRepository"); } }在配置文件中定义这两个 Bean：
<bean id="userRepository" class="com.example.demo.repository.UserRepository"/> <bean id="userService" class="com.example.demo.service.UserService"> <constructor-arg ref="userRepository"/> </bean>当 Spring 容器创建
UserService实例时，会首先实例化
UserRepository，随后通过构造函数将该实例注入到目标类中。此时控制台将依次输出：“UserRepository 被实例化” 和 “UserService 被实例化，注入 UserRepository”。
Setter 方法注入则是通过调用 Bean 提供的 Setter 方法来实现依赖的注入。示例如下：
public class UserService { private UserRepository userRepository; public void setUserRepository(UserRepository userRepository) { this.userRepository = userRepository; System.out.println("通过Setter方法注入UserRepository"); } }对应的配置文件内容为：
<bean id="userRepository" class="com.example.demo.repository.UserRepository"/> <bean id="userService" class="com.example.demo.service.UserService"> <property name="userRepository" ref="userRepository"/> </bean>字段注入方式最为简洁，仅需使用
@Autowired注解即可自动完成注入：
public class UserService { @Autowired private UserRepository userRepository; }Spring 容器会自动识别并注入合适的
UserRepository实例。
4.3 初始化（Initialization）
进入初始化阶段后，若已配置初始化方法，则 Spring 将自动调用相应逻辑。框架提供了多种定义初始化行为的方式，包括使用
@PostConstruct注解的方法、实现
InitializingBean接口，或通过配置文件指定自定义的
init-method方法。
其中，
@PostConstruct是 Java 标准注解，被其标记的方法将在所有依赖注入完成后立即执行。例如：
import javax.annotation.PostConstruct; import org.springframework.stereotype.Component; @Component public class UserService { @PostConstruct public void init() { System.out.println("@PostConstruct注解的init方法被调用"); } }另一种方式是实现
InitializingBean接口，并重写
afterPropertiesSet方法以完成初始化操作：
import org.springframework.beans.factory.InitializingBean; import org.springframework.stereotype.Component; @Component public class UserService implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { System.out.println("InitializingBean接口的afterPropertiesSet方法被调用"); } }此外，也可在配置文件中通过
init-method属性指定自定义初始化方法：
public class UserService { public void customInit() { System.out.println("自定义init-method方法customInit被调用"); } }完整的配置文件如下：
<bean id="userService" class="com.example.demo.service.UserService" init-method="customInit"/>这三种方式的执行顺序为：
@PostConstruct注解方法 →
InitializingBean接口中的
afterPropertiesSet方法 → 自定义
init-method方法。
4.4 销毁（Destruction）
当 Spring 容器关闭时，Bean 进入销毁阶段。如果配置了销毁逻辑，系统将按序调用相应的清理方法。Spring 提供了以下三种机制来定义销毁行为：
@PreDestroy注解方法、实现
DisposableBean接口，以及通过配置文件设置自定义的
destroy-method方法。
被
@PreDestroy注解标注的方法会在 Bean 销毁前被触发：
import javax.annotation.PreDestroy; import org.springframework.stereotype.Component; @Component public class UserService { @PreDestroy public void destroy() { System.out.println("@PreDestroy注解的destroy方法被调用"); } }也可以选择实现
DisposableBean接口并重写
destroy方法来执行资源释放逻辑：
import org.springframework.beans.factory.DisposableBean; import org.springframework.stereotype.Component; @Component public class UserService implements DisposableBean { @Override public void destroy() throws Exception { System.out.println("DisposableBean接口的destroy方法被调用"); } }或者，在配置文件中利用
destroy-method属性指定销毁回调：
public class UserService { public void customDestroy() { System.out.println("自定义destroy-method方法customDestroy被调用"); } }相关配置文件内容如下：
<bean id="userService" class="com.example.demo.service.UserService" destroy-method="customDestroy"/>上述三种方式的调用顺序为：
@PreDestroy注解方法优先执行，接着是
DisposableBean接口的
destroy方法，最后执行自定义的
destroy-method方法。
五、Spring Bean 生命周期的扩展点
5.1 Bean 自身的方法
Bean 自身的方法贯穿整个生命周期，构成了基础的执行流程，主要包括构造函数、Setter 方法，以及由
<bean>标签中
init-method和
destroy-method属性所指定的初始化与销毁方法。
构造函数作为 Bean 实例化的起点，负责构建对象的初始状态。例如，在一个
OrderService类中，可通过构造函数初始化必要资源：
public class OrderService { private OrderRepository orderRepository; public OrderService() { System.out.println("OrderService构造函数被调用"); } public OrderService(OrderRepository orderRepository) { this.orderRepository = orderRepository; System.out.println("带参数的OrderService构造函数被调用，注入OrderRepository"); } }Setter 方法则在属性赋值阶段发挥作用，用于注入外部依赖。比如，向
OrderService注入
OrderRepository实例：
public class OrderService { private OrderRepository orderRepository; public void setOrderRepository(OrderRepository orderRepository) { this.orderRepository = orderRepository; System.out.println("通过Setter方法注入OrderRepository"); } }由
init-method指定的方法会在初始化阶段运行，常用于执行诸如连接数据库、加载配置文件等前置准备任务。例如，定义一个
init方法来初始化业务规则：
public class OrderService { public void init() { System.out.println("init-method指定的init方法被调用，初始化业务规则"); } }在 Spring 配置文件中进行如下声明：
<bean id="orderService" class="com.example.demo.service.OrderService" init-method="init"/>而由
destroy-method指定的方法则在容器关闭时被执行，主要用于资源回收，如关闭数据库连接、释放线程池等。例如，定义一个
destroy方法用于清理
OrderService持有的资源：
public class OrderService { public void destroy() { System.out.println("destroy-method指定的destroy方法被调用，释放资源"); } }配置文件中的对应设置为：
<bean id="orderService" class="com.example.demo.service.OrderService" destroy-method="destroy"/>这些由 Bean 自身定义的方法紧密配合生命周期各阶段，赋予开发者对初始化和销毁过程的直接控制能力。
5.2 容器级的方法（BeanPostProcessor 一系列接口）
容器级别的扩展主要通过
BeanPostProcessor及其子接口实现，为 Spring 容器创建 Bean 的全过程提供了强大的可插拔机制。
其中，
BeanPostProcessor接口定义了两个核心方法：
postProcessBeforeInitialization和
postProcessAfterInitialization。它们分别在 Bean 初始化前后被调用，允许开发者对 Bean 实例进行定制化处理。例如，可以创建一个
CustomBeanPostProcessor实现类，用于记录每个 Bean 的初始化日志：
import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.stereotype.Component; @Component public class CustomBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("在Bean " + beanName + " 初始化前执行自定义逻辑"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("在Bean " + beanName + " 初始化后执行自定义逻辑"); return bean; } }此外，
InstantiationAwareBeanPostProcessor作为
BeanPostProcessor的子接口，提供了更细粒度的扩展支持。例如，
postProcessBeforeInstantiationpostProcessAfterInstantiationOrderServiceCustomInstantiationAwareBeanPostProcessorimport org.springframework.beans.BeansException; import org.springframework.beans.PropertyValues; import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; import org.springframework.stereotype.Component; @Component public class CustomInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { if ("orderService".equals(beanName)) { System.out.println("在OrderService实例化前执行自定义逻辑"); } return null; } @Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if ("orderService".equals(beanName)) { System.out.println("在OrderService实例化后执行自定义逻辑"); } return true; } @Override public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { if ("orderService".equals(beanName)) { System.out.println("在OrderService属性赋值阶段执行自定义逻辑，修改属性值"); // 这里可以对pvs进行修改，例如添加或替换属性值 } return pvs; } }nullpostProcessPropertyValuesBeanPostProcessor
京公网安备 11010802022788号
