Spring Bean 生命周期

1. 生命周期完整流程（简化版）

2. 代码示例：直观感受生命周期

java 复制代码

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

// 标注为 Spring 组件，让容器管理这个 Bean
@Component
public class UserBean implements InitializingBean, DisposableBean {

    // 1. 实例化时的构造方法
    public UserBean() {
        System.out.println("1. Bean 构造方法执行（实例化）");
    }

    // 2. 属性填充（假设注入一个属性）
    private String username;
    public void setUsername(String username) {
        this.username = username;
        System.out.println("2. 属性填充：注入 username = " + username);
    }

    // 3. 初始化前：需自定义 BeanPostProcessor 才能看到，这里省略（全局生效）

    // 4. 初始化阶段 - 第一步：@PostConstruct 注解
    @PostConstruct
    public void postConstruct() {
        System.out.println("4-1. @PostConstruct 初始化方法执行");
    }

    // 4. 初始化阶段 - 第二步：实现 InitializingBean 接口的 afterPropertiesSet 方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("4-2. InitializingBean.afterPropertiesSet() 执行");
    }

    // 4. 初始化阶段 - 第三步：自定义 init-method（需在配置中指定，如 @Bean(initMethod = "initMethod")）
    public void initMethod() {
        System.out.println("4-3. 自定义 init-method 执行");
    }

    // 5. 初始化后：BeanPostProcessor.postProcessAfterInitialization（AOP 增强在此）

    // 6. 使用阶段：业务方法
    public void doBusiness() {
        System.out.println("6. Bean 就绪，执行业务方法：username = " + username);
    }

    // 7. 销毁阶段 - 第一步：@PreDestroy 注解
    @PreDestroy
    public void preDestroy() {
        System.out.println("7-1. @PreDestroy 销毁前方法执行");
    }

    // 7. 销毁阶段 - 第二步：实现 DisposableBean 接口的 destroy 方法
    @Override
    public void destroy() throws Exception {
        System.out.println("7-2. DisposableBean.destroy() 执行");
    }

    // 7. 销毁阶段 - 第三步：自定义 destroy-method（需在配置中指定）
    public void destroyMethod() {
        System.out.println("7-3. 自定义 destroy-method 执行");
    }
}

java 复制代码

import org.example.musicA.pojo.UserBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;

/**
 * @author liuqin
 * @create 2026/2/12 9:20
 */
public class AppConfig {

    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public UserBean userBean() {
        UserBean userBean = new UserBean();
        userBean.setUsername("张三");
        return userBean;
    }

    public static void main(String[] args) {
        // 启动 Spring 容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 获取 Bean 并调用业务方法
        UserBean userBean = context.getBean(UserBean.class);
        userBean.doBusiness();
        // 关闭容器，触发 Bean 销毁
        context.close();
    }
}

java 复制代码

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userBean".equals(beanName) && bean instanceof UserBean) {
            System.out.println("3. BeanPostProcessor.postProcessBeforeInitialization");
        }
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userBean".equals(beanName) && bean instanceof UserBean) {
            System.out.println("5. BeanPostProcessor.postProcessAfterInitialization");
        }
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

执行结果：

bash 复制代码

1. Bean 构造方法执行（实例化）
2. 属性填充：注入 username = 张三
3. BeanPostProcessor.postProcessBeforeInitialization
4-1. @PostConstruct 初始化方法执行
4-2. InitializingBean.afterPropertiesSet() 执行
4-3. 自定义 init-method 执行
5. BeanPostProcessor.postProcessAfterInitialization
6. Bean 就绪，执行业务方法：username = 张三
09:50:24.783 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@4361bd48, started on Thu Feb 12 09:50:23 CST 2026
7-1. @PreDestroy 销毁前方法执行
7-2. DisposableBean.destroy() 执行
7-3. 自定义 destroy-method 执行

核心扩展点说明

BeanPostProcessor：全局后置处理器，可拦截所有 Bean 的初始化前后阶段，是 Spring 实现 AOP、注解解析的核心（比如 @Autowired 注解的解析就依赖它）。
初始化优先级：@PostConstruct > InitializingBean.afterPropertiesSet() > 自定义 init-method。
销毁优先级：@PreDestroy > DisposableBean.destroy() > 自定义 destroy-method。
只有单例 Bean 会完整执行生命周期（包括销毁），原型 Bean 由 Spring 创建并初始化后，就交给用户管理，容器不会销毁它。

3. 总结

Spring Bean 生命周期核心分为：实例化 → 属性填充 → 初始化 → 使用 → 销毁五大步骤。
初始化和销毁阶段有多个扩展点，且执行顺序固定（注解 > 接口 > 自定义方法）。
单例 Bean 由容器全程管理生命周期，原型 Bean仅初始化前的阶段由容器管理，销毁由用户负责。