Spring Bean 生命周期

Bean 生命周期指的是从 Spring 容器创建一个 Bean 到销毁它的整个过程。Spring 通过管理 Bean 的生命周期来帮助我们控制 Bean 的创建、初始化、使用和销毁。

Spring Bean 生命周期

1. 实例化：
   通过构造函数或工厂方法创建 Bean 的实例。
2. 属性赋值（依赖注入）：
   Spring 会为 Bean 设置依赖的属性（也就是依赖注入，通常是通过构造器、Setter 方法或者字段注入）。

3. 调用 BeanPostProcessor 的 postProcessBeforeInitialization 方法：
   在此步骤，Spring 容器会检查是否有实现了 BeanPostProcessor 接口的类。如果有，它们会在初始化前对 Bean 进行修改或操作（例如：做一些验证、修改 Bean 的状态等）。

   • BeanPostProcessor 是一个扩展接口，在它实现的 postProcessBeforeInitialization 方法中，可以对 Bean 做一些处理。

4. 初始化方法：

   • 如果 Bean 定义了 init-method，Spring 会在此时调用该方法。
   • 如果 Bean 实现了 InitializingBean 接口，Spring 会调用它的 afterPropertiesSet() 方法。
5. 调用 BeanPostProcessor 的 postProcessAfterInitialization 方法：
   同样，Spring 容器会检查是否有 BeanPostProcessor，并在 Bean 初始化之后调用它们的 postProcessAfterInitialization 方法。这使得开发者可以在 Bean 完成初始化后做一些操作。
6. 使用 Bean：
   经过上面的处理后，Bean 就会在 Spring 容器中处于准备就绪的状态，可以被应用程序代码所使用。Bean 会继续在 Spring 容器中被管理，直到销毁。

7. 销毁：
   当 Spring 容器关闭时，所有的 Bean 会被销毁。

   • 如果 Bean 定义了 destroy-method，Spring 会调用该方法。
   • 如果 Bean 实现了 DisposableBean 接口，Spring 会调用它的 destroy() 方法。

Spring Bean 生命周期的详细流程图：

+-------------------+
| Bean 被实例化      |
+-------------------+
          ↓
+-------------------+
| 依赖注入           |
+-------------------+
          ↓
+-------------------+
| 调用 postProcessBeforeInitialization |
+-------------------+
          ↓
+-------------------+
| 调用初始化方法     |
| (init-method 或  |
| InitializingBean) |
+-------------------+
          ↓
+-------------------+
| 调用 postProcessAfterInitialization |
+-------------------+
          ↓
+-------------------+
| Bean 被使用       |
+-------------------+
          ↓
+-------------------+
| 容器销毁          |
+-------------------+
          ↓
+-------------------+
| 调用 destroy 方法  |
| (destroy-method 或 |
| DisposableBean)   |
+-------------------+

具体实现步骤：

1. 配置 Bean：

   你可以在 Spring 的配置文件（如 applicationContext.xml）中指定 init-method 和 destroy-method：

   <bean id="myBean" class="com.example.MyBean" init-method="init" destroy-method="cleanup">
       <!-- 依赖注入 -->
   </bean>

   或者使用注解：

   @Component
   public class MyBean {
       @PostConstruct
       public void init() {
           System.out.println("Bean 初始化");
       }
   
       @PreDestroy
       public void cleanup() {
           System.out.println("Bean 销毁");
       }
   }

2. 实现 InitializingBean 和 DisposableBean：

   Spring 提供了 InitializingBean 和 DisposableBean 接口，它们分别定义了初始化和销毁方法。

   @Component
   public class MyBean implements InitializingBean, DisposableBean {
   
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("Bean 初始化");
       }
   
       @Override
       public void destroy() throws Exception {
           System.out.println("Bean 销毁");
       }
   }

3. 实现 BeanPostProcessor：

   BeanPostProcessor 是一个接口，它允许在 Bean 的初始化前后进行处理：

   @Component
   public class MyBeanPostProcessor 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;
       }
   }

生命周期中常用的注解：

• @PostConstruct：该注解的方法会在依赖注入完成后、Bean 初始化方法执行之前调用。
• @PreDestroy：该注解的方法会在销毁之前执行。

总结：

Spring Bean 的生命周期分为几个主要的阶段：实例化、依赖注入、初始化、销毁等。在这整个过程中，Spring 提供了多种机制（如 BeanPostProcessor、InitializingBean、DisposableBean、@PostConstruct 和 @PreDestroy）来帮助开发者在不同阶段对 Bean 进行定制操作。