Spring Bean的生命周期

  一、 前言： 

        今天我们来说一说 Spring Bean 的生命周期，首先我是把他分成了三个层次的步骤版本去分析的 ，因为我觉的这样通俗易懂。那么下面可以看看我的这个三个层次的步骤：

 在分析这个生命周期之前 我们可以先了解一下Bean。

二、什么是 Bean

简而言之，bean 是由 Spring IoC 容器实例化、组装和管理的对象。

三、 什么是 Spring Bean 的生命周期

对于普通的 Java 对象，当 new 的时候创建对象，然后该对象就能够使用了。一旦该对象不再被使用，则由 Java 自动进行垃圾回收。

而 Spring 中的对象是 bean，bean 和普通的 Java 对象没啥大的区别，只不过 Spring 不再自己去 new 对象了，而是由 IoC 容器去帮助我们实例化对象并且管理它，我们需要哪个对象，去问 IoC 容器要即可。IoC 其实就是解决对象之间的耦合问题，Spring Bean 的生命周期完全由容器控制。

四、 Spring Bean 的生命周期（10 步骤详解）

1. 实例化（Instantiation）：创建 Bean 的实例对象，此时只是一个空对象，还未设置任何属性。

源码分析：由 BeanFactory 的createBean()方法触发，通过反射调用 Bean 的构造方法。

// 简化版实例化逻辑protected Object createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // 1. 解析Bean的类信息 Class beanClass = resolveBeanClass(mbd, beanName); // 2. 选择合适的构造方法 Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); // 3. 通过反射实例化对象 return instantiateBean(beanName, mbd, ctors, args);}

2.依赖注入（Dependency Injection）：为 Bean 的属性设置值，注入依赖的其他 Bean。

3.BeanNameAware 与 BeanFactoryAware 接口方法执行:让 Bean 获取自身在容器中的名称和 BeanFactory 的引用

相关接口：

public interface BeanNameAware { void setBeanName(String name); // 设置Bean在容器中的名称}public interface BeanFactoryAware { void setBeanFactory(BeanFactory beanFactory) throws BeansException; // 设置BeanFactory引用}

4.初始化前：BeanPostProcessor 的 before 方法：在 Bean 初始化前对其进行增强处理

public interface BeanPostProcessor { // 初始化前调用 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; }}

5. InitializingBean 接口的方法执行：提供 Bean 初始化的回调方法，在属性设置完成后执行

相关接口：

public interface InitializingBean { void afterPropertiesSet() throws Exception; // 属性设置完成后调用}

6.初始化（Custom Initialization）：执行用户自定义的初始化逻辑

7. 初始化后：BeanPostProcessor 的 after 方法：在 Bean 初始化后对其进行增强处理

public interface BeanPostProcessor { // 初始化后调用 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; }}

8.使用 Bean（In Use）：

Bean 已完全初始化，可被应用程序使用

状态：此时 Bean 处于可用状态，Spring 容器会一直持有 Bean 的引用

注意：单例 Bean 会一直存在于容器中，原型 Bean 使用后由 JVM 垃圾回收

9.DisposableBean 接口的方法执行:在 Bean 销毁前执行清理操作

public interface DisposableBean { void destroy() throws Exception; // Bean销毁前调用}

10.销毁 Bean（Destruction）:执行用户自定义的销毁逻辑，释放资源

五、Spring Bean的作用

1. 实现控制反转（IoC），降低耦合度

Spring 容器负责 Bean 的创建、初始化、依赖注入和销毁等生命周期管理，开发者无需手动通过 new 关键字创建对象，也无需关注对象之间的依赖关系。

例如，当一个类 A 需要依赖类 B 时，无需在 A 中主动创建 B 的实例，而是由 Spring 容器将 B 的实例（Bean）自动注入到 A 中。这种方式极大地降低了类之间的直接依赖，使得代码更易于维护和扩展。

2. 提供统一的生命周期管理

Spring 为 Bean 定义了完整的生命周期（如实例化、依赖注入、初始化、销毁等），并允许开发者在生命周期的不同阶段进行自定义操作（例如通过 InitializingBean 接口、@PostConstruct 注解执行初始化逻辑，通过 DisposableBean 接口、@PreDestroy 注解执行销毁逻辑）。

这种统一的生命周期管理确保了 Bean 在不同阶段的行为可预测，便于资源的初始化（如数据库连接）和释放（如关闭连接）。

3. 支持依赖注入（DI）

依赖注入是 IoC 的具体实现，Spring Bean 之间的依赖关系由容器自动维护。容器会根据配置（如 XML、注解 @Autowired 等）将所需的依赖 Bean 注入到目标 Bean 中。

例如，Service 层的 Bean 依赖于 Dao 层的 Bean 时，Spring 会自动将 Dao 层 Bean 注入到 Service 层 Bean 中，开发者无需手动处理依赖，减少了代码的冗余。

4. 集成 Spring 生态的核心载体

Spring 框架的众多功能（如 AOP、事务管理、缓存、安全等）都是以 Bean 为基础实现的。AOP（面向切面编程）：通过对 Bean 进行代理，实现日志记录、性能监控、异常处理等横切逻辑，而无需修改 Bean 自身的代码。

事务管理：Spring 的声明式事务通过对 Service 层的 Bean 进行增强，自动管理事务的提交或回滚。

其他功能：缓存（如 @Cacheable）、异步处理（如 @Async）等功能，均需通过 Spring 容器对 Bean 进行特殊处理来实现。

5. 支持多种作用域（Scope）

    Spring 为 Bean 提供了多种作用域，可根据业务需求灵活选择，常见的包括：

    单例（Singleton）：默认作用域，容器中只存在一个 Bean 实例，全局共享。

   原型（Prototype）：每次请求都会创建一个新的 Bean 实例。

   请求（Request）：每个 HTTP 请求对应一个 Bean 实例（仅用于 Web 应用）。

    会话（Session）：每个 HTTP 会话对应一个 Bean 实例（仅用于 Web 应用）。

     不同的作用域满足了不同场景下的资源管理需求，例如单例适用于无状态组件（如工具类），        原型适用于有状态组件。

6. 简化企业级开发

Spring Bean 作为组件的载体，遵循了面向对象的设计原则，便于将应用拆分为多个职责单一的组件（如 Controller、Service、Dao 等），实现 “高内聚、低耦合”。

容器对 Bean 的集中管理，使得开发者可以更专注于业务逻辑的实现，而非对象的创建和管理，从而提高开发效率。

六、代码演示：

Dog：

package com.apesource.bean;import org.springframework.beans.factory.BeanNameAware;import org.springframework.beans.factory.DisposableBean;import org.springframework.beans.factory.InitializingBean;public class Dog implements BeanNameAware, InitializingBean, DisposableBean { private String name; public Dog() { System.out.println(\"1.实例化\"); } public Dog(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { System.out.println(\"2.依赖注入\"); this.name = name; } public void doInit(){ System.out.println(\"6.初始化\"); } public void dodestory(){ System.out.println(\"10.销毁Bean\"); } @Override public void setBeanName(String s) { System.out.println(\"3.BeanNameAware BeanFactoryAware方法执行啦\"); } @Override public void afterPropertiesSet() throws Exception { System.out.println(\"5.InitialingBean接口的方法执行啦\"); } @Override public void destroy() throws Exception { System.out.println(\"9.DisposableBean接口的方法执行啦\"); }}

MyProcessor：

package com.apesource.bean;import org.springframework.beans.factory.config.BeanPostProcessor;public class MyProcessor implements BeanPostProcessor{ @Override public Object postProcessBeforeInitialization(Object o,String s){ if(\"dog\".equals(s)){ System.out.println(\"4.初始化前 BeanPostProcessor before方法执行啦\"); } return null; } @Override public Object postProcessAfterInitialization(Object o,String s){ if(\"dog\".equals(s)){ System.out.println(\"7.初始化后 BeanPostProcessor after方法执行啦\"); } return null; }}

applicationContext.xml

测试：

package com.apesource;import com.apesource.bean.Dog;import junit.framework.TestCase;import junit.framework.TestSuite;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/** * 测试生命周期 */public class AppTest{ public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext(\"applicationContext.xml\"); context.getBean(Dog.class); System.out.println(\"8.使用Bean\"); ((ClassPathXmlApplicationContext) context).close(); }}

控制台输出结果：

七、总结：

Spring Bean 是 Spring 容器管理的对象，它不仅是应用程序的核心组件，也是 Spring 框架实现 IoC、DI、AOP 等核心功能的基础。通过对 Bean 的生命周期、依赖关系和作用域的管理，Spring 极大地简化了企业级应用的开发，提升了代码的可维护性和扩展性。