怡格网 | 详情

Spring 中 Bean 的生命周期

Spring 中 Bean 的生命周期是指 Bean 从创建到销毁的整个过程，主要包含以下几个关键阶段：

1. 实例化（Instantiation）

这是 Bean 生命周期的第一步，Spring 容器会根据配置信息（如 XML 配置、注解等）使用反射机制创建 Bean 的实例对象。例如，当使用 @Component 注解标注一个类时，Spring 容器会在启动时自动扫描并实例化该类。

2. 属性赋值（Populate properties）

在 Bean 实例创建完成后，Spring 容器会根据配置信息为 Bean 的属性进行赋值。可以通过 XML 中的 <property> 标签、注解（如 @Autowired、@Value 等）来完成属性的注入。

3. 初始化（Initialization）

实现 InitializingBean 接口：如果 Bean 实现了 InitializingBean 接口，Spring 容器会调用其 afterPropertiesSet() 方法。这个方法通常用于在 Bean 的属性设置完成后执行一些初始化操作。
自定义初始化方法：可以通过在 Bean 类中定义一个自定义的初始化方法，并在配置文件（XML 或注解）中指定该方法。例如，使用 @PostConstruct 注解标注一个方法，Spring 容器会在属性赋值完成后调用该方法。
BeanPostProcessor 前置处理：BeanPostProcessor 是 Spring 提供的一个扩展接口，它允许在 Bean 初始化前后进行额外的处理。postProcessBeforeInitialization() 方法会在 Bean 的初始化方法调用之前执行。

4. 使用（In Use）

经过前面的步骤，Bean 已经完成了初始化，可以被应用程序使用。在应用程序中，可以通过依赖注入的方式获取并使用这些 Bean。

5. 销毁（Destruction）

实现 DisposableBean 接口：如果 Bean 实现了 DisposableBean 接口，Spring 容器会在销毁 Bean 时调用其 destroy() 方法。
自定义销毁方法：可以通过在 Bean 类中定义一个自定义的销毁方法，并在配置文件（XML 或注解）中指定该方法。例如，使用 @PreDestroy 注解标注一个方法，Spring 容器会在销毁 Bean 之前调用该方法。
BeanPostProcessor 后置处理：BeanPostProcessor 的 postProcessAfterInitialization() 方法会在 Bean 的销毁方法调用之后执行。

自定义 Bean 的生命周期

可以通过以下几种方式自定义 Bean 的生命周期：

1. 实现 `InitializingBean` 和 `DisposableBean` 接口

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化操作
        System.out.println("MyBean: Initializing...");
    }

    @Override
    public void destroy() throws Exception {
        // 销毁操作
        System.out.println("MyBean: Destroying...");
    }
}

在配置文件中配置该 Bean：

<bean id="myBean" class="com.example.MyBean"/>

2. 使用 `@PostConstruct` 和 `@PreDestroy` 注解

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyAnnotatedBean {

    @PostConstruct
    public void init() {
        // 初始化操作
        System.out.println("MyAnnotatedBean: Initializing...");
    }

    @PreDestroy
    public void cleanup() {
        // 销毁操作
        System.out.println("MyAnnotatedBean: Destroying...");
    }
}

在配置类中使用 @Component 注解将该类注册为 Bean：

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

3. 在 XML 配置中指定初始化和销毁方法

public class MyXmlBean {

    public void initMethod() {
        // 初始化操作
        System.out.println("MyXmlBean: Initializing...");
    }

    public void destroyMethod() {
        // 销毁操作
        System.out.println("MyXmlBean: Destroying...");
    }
}

在 XML 配置文件中指定初始化和销毁方法：

<bean id="myXmlBean" class="com.example.MyXmlBean" init-method="initMethod" destroy-method="destroyMethod"/>

4. 实现 `BeanPostProcessor` 接口

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在 Bean 初始化之前执行的操作
        System.out.println("Before initializing bean: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在 Bean 初始化之后执行的操作
        System.out.println("After initializing bean: " + beanName);
        return bean;
    }
}

这样，Spring 容器在初始化每个 Bean 时，都会调用 MyBeanPostProcessor 的 postProcessBeforeInitialization() 和 postProcessAfterInitialization() 方法。