【Spring篇】Spring的生命周期

news2025/3/30 11:17:13

一、Bean 生命周期的核心阶段

1. 实例化（Instantiation）

• 触发时机：容器启动时（单例 Bean）或请求时（原型 Bean）。
• 实现方式：
通过反射（Class.newInstance() 或构造器）创建 Bean 的实例。

2. 属性赋值（Population）

• 依赖注入：
通过字段注入（@Autowired）、Setter 注入或构造器注入为 Bean 的属性赋值。
• 处理 Aware 接口：
若 Bean 实现了 BeanNameAware、BeanFactoryAware 等接口，容器会回调对应方法。

public class MyBean implements BeanNameAware {
    private String beanName;
    @Override
    public void setBeanName(String name) {
        this.beanName = name; // 获取 Bean 的名称
    }
}

3. BeanPostProcessor 的前置处理

• 调用 postProcessBeforeInitialization：
在 Bean 初始化前执行自定义逻辑（如修改 Bean 属性）。

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 对 Bean 进行前置处理
        return bean;
    }
}

4. 初始化（Initialization）

• @PostConstruct 注解方法：
标记在方法上，容器会调用该方法。

@PostConstruct
public void init() {
    // 初始化逻辑
}

• InitializingBean 接口：
实现 afterPropertiesSet() 方法。

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() {
        // 属性赋值完成后执行
    }
}

• XML 配置的 init-method：
在 XML 中指定初始化方法。

<bean id="myBean" class="com.example.MyBean" init-method="customInit"/>

5. BeanPostProcessor 的后置处理

• 调用 postProcessAfterInitialization：
在 Bean 初始化后执行自定义逻辑（如生成代理对象）。

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    // 对 Bean 进行后置处理（如 AOP 代理）
    return bean;
}

6. Bean 就绪（In Use）

• 业务使用阶段：
Bean 被应用程序代码调用，执行业务逻辑。

7. 销毁（Destruction）

• @PreDestroy 注解方法：
标记在方法上，容器销毁前调用。

@PreDestroy
public void cleanup() {
    // 释放资源逻辑
}

• DisposableBean 接口：
实现 destroy() 方法。

public class MyBean implements DisposableBean {
    @Override
    public void destroy() {
        // 容器销毁时执行
    }
}

• XML 配置的 destroy-method：
在 XML 中指定销毁方法。

<bean id="myBean" class="com.example.MyBean" destroy-method="customDestroy"/>

二、生命周期的完整流程图

实例化 → 属性赋值 → BeanPostProcessor前置处理 → 初始化 → BeanPostProcessor后置处理 → 使用 → 销毁

三、扩展点与高级特性

1. Aware 接口

• 作用：让 Bean 感知容器环境。
• 常见接口：
• BeanNameAware：获取 Bean 的名称。
• BeanFactoryAware：获取 BeanFactory 引用。
• ApplicationContextAware：获取 ApplicationContext 引用。

2. BeanPostProcessor

• 核心用途：
在 Bean 初始化前后插入自定义逻辑（如 AOP 代理、属性加密）。
• 典型场景：
Spring AOP 通过 AbstractAutoProxyCreator（BeanPostProcessor 的子类）生成代理对象。

3. BeanFactoryPostProcessor

• 作用：
在 Bean 定义加载后、实例化前修改 Bean 的定义（如修改属性值）。

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinition beanDef = beanFactory.getBeanDefinition("myBean");
        beanDef.getPropertyValues().add("property", "newValue");
    }
}

4. 作用域对生命周期的影响

• 单例（Singleton）：
容器启动时创建，容器关闭时销毁。
• 原型（Prototype）：
每次请求时创建，容器不管理其销毁。
• 其他作用域：
• Request/Session（Web 环境）：生命周期与请求或会话绑定。
• 自定义作用域：通过 Scope 接口扩展。

四、示例代码：完整生命周期演示

1. Bean 类

public class LifecycleBean implements BeanNameAware, InitializingBean, DisposableBean {
    private String beanName;

    @Override
    public void setBeanName(String name) {
        this.beanName = name; // BeanNameAware 回调
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("@PostConstruct 方法调用");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean.afterPropertiesSet() 调用");
    }

    public void customInit() {
        System.out.println("XML init-method 调用");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("@PreDestroy 方法调用");
    }

    @Override
    public void destroy() {
        System.out.println("DisposableBean.destroy() 调用");
    }

    public void customDestroy() {
        System.out.println("XML destroy-method 调用");
    }
}

2. BeanPostProcessor

public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("BeanPostProcessor.postProcessBeforeInitialization() 调用");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("BeanPostProcessor.postProcessAfterInitialization() 调用");
        }
        return bean;
    }
}

3. 输出结果

实例化 LifecycleBean
BeanNameAware.setBeanName() 调用
BeanPostProcessor.postProcessBeforeInitialization() 调用
@PostConstruct 方法调用
InitializingBean.afterPropertiesSet() 调用
XML init-method 调用
BeanPostProcessor.postProcessAfterInitialization() 调用
...（Bean 使用阶段）...
@PreDestroy 方法调用
DisposableBean.destroy() 调用
XML destroy-method 调用

五、总结

核心阶段：实例化 → 属性注入 → 初始化 → 销毁。
关键扩展点：
• Aware 接口（获取容器信息）。
• BeanPostProcessor（初始化前后处理）。
• @PostConstruct/@PreDestroy（注解回调）。
• InitializingBean/DisposableBean（接口回调）。
作用域影响：单例和原型 Bean 的生命周期差异。
设计思想：通过回调接口和扩展点实现松耦合和可定制化。