Spring Bean 生命周期详解：从创建到销毁的完整旅程

Spring Bean 生命周期详解：从创建到销毁的完整旅程
（基于 Spring 6.x / Spring Boot 4.x，2026年3月最新视角）

Spring Bean 的生命周期是 Spring 框架最核心、最容易被问到的面试/生产知识点之一。
它总共分为 11 个主要阶段（含 Aware 接口回调），掌握之后，你就能轻松回答：

• 为什么 @PostConstruct 比 init-method 更早执行？
• BeanPostProcessor 在哪里插入？前后各做什么？
• 如何实现自定义 Bean 的初始化/销毁逻辑？

下面用 图 + 表格 + 代码 + 顺序 一次性讲透。

一、Spring Bean 生命周期全流程图（建议手画一遍）

1. 实例化 Instantiation
2. 属性注入 Populate Properties
3. Aware 接口回调
4. BeanPostProcessor Before
5. 初始化 Initialization（@PostConstruct → afterPropertiesSet → init-method）
6. BeanPostProcessor After
7. Bean 可用 Ready
8. 容器关闭 → 销毁 Destruction（@PreDestroy → destroy() → destroy-method）

二、11 个阶段详细拆解（2026年最完整版）

阶段	触发时机	关键方法 / 接口	执行顺序	说明 & 常用场景
1. 实例化	BeanDefinition → new 对象	构造方法 / 工厂方法	最先	无参构造 / @Autowired 构造注入（Spring 6+ 推荐）
2. 属性注入	依赖注入	Setter / 字段注入 / @Autowired	构造后	populateBean() 方法
3. Aware 回调	注入 BeanFactory / Context 等	BeanNameAware、BeanFactoryAware、ApplicationContextAware、EnvironmentAware、ResourceLoaderAware 等	属性注入后	获取容器资源、当前 Bean 名字
4. BeanPostProcessor Before	所有 BeanPostProcessor	postProcessBeforeInitialization	初始化前	AOP 代理创建、@Value 注入、@ConfigurationProperties 绑定
5. 初始化 – @PostConstruct	JSR-250	@PostConstruct 注解方法	最先	推荐方式，Jakarta EE 标准
6. 初始化 – InitializingBean	接口	afterPropertiesSet()	中间	Spring 官方接口
7. 初始化 – init-method	XML / @Bean(initMethod=)	自定义 init 方法	最后	兼容老项目
8. BeanPostProcessor After	所有 BeanPostProcessor	postProcessAfterInitialization	初始化后	AOP 最终代理返回、@Async 等
9. Bean 就绪	容器启动完成	–	使用阶段	正常提供服务
10. 容器关闭	ApplicationContext.close() / JVM 退出	–	销毁开始	SmartLifecycle 也可参与
11. 销毁	销毁阶段	@PreDestroy → DisposableBean.destroy() → destroy-method	最后	释放资源（连接池、线程池、缓存清理）

三、核心代码示例（直接可运行验证）

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class MyLifecycleBean implements 
        BeanNameAware,
        BeanFactoryAware,
        ApplicationContextAware,
        InitializingBean,
        DisposableBean {

    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;

    public MyLifecycleBean() {
        System.out.println("1. 【构造方法】实例化");
    }

    @Autowired
    public void setSomething(String dummy) {
        System.out.println("2. 【属性注入】");
    }

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. 【BeanNameAware】beanName = " + name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
        System.out.println("3. 【BeanFactoryAware】");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        System.out.println("3. 【ApplicationContextAware】");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("5. 【@PostConstruct】");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6. 【InitializingBean.afterPropertiesSet】");
    }

    public void customInit() {
        System.out.println("7. 【init-method】");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("11. 【@PreDestroy】");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("11. 【DisposableBean.destroy】");
    }

    public void customDestroy() {
        System.out.println("11. 【destroy-method】");
    }
}

@Bean 配置方式（推荐在 Config 类中使用）：

@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public MyLifecycleBean myBean() {
    return new MyLifecycleBean();
}

四、BeanPostProcessor 插桩位置（最容易混淆）

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("4. 【Before】" + beanName);
        // 这里可以做 AOP 代理、校验等
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("8. 【After】" + beanName);
        // 这里拿到最终代理对象
        return bean;
    }
}

五、2026年最新变化 & 最佳实践

1. 构造方法注入优先（Spring 6+ 强烈推荐，无需 @Autowired）
2. @PostConstruct / @PreDestroy 是 JSR-250 标准，已成为主流
3. AOP 代理在 BeanPostProcessor After 阶段完成（因此循环依赖时代理对象已存在）
4. SmartInitializingSingleton 在所有单例初始化完成后回调（用于延迟初始化）
5. Spring Boot 4.x 默认使用 Jakarta EE（jakarta.annotation.），不再是 javax.

六、常见面试/生产问题一次性回答

Q：多个初始化方法执行顺序？
A：@PostConstruct → afterPropertiesSet() → init-method

Q：BeanPostProcessor 是全局还是单个 Bean？
A：全局，所有 Bean 都会走一遍

Q：循环依赖如何解决？
A：三级缓存 + BeanPostProcessor 提前暴露半成品

Q：如何自定义全局初始化/销毁逻辑？
A：实现 BeanPostProcessor 或 SmartLifecycle

掌握上面这套流程，你在任何 Spring 面试中“Bean 生命周期”这题都能拿满分，生产中写 Lifecycle Bean 也能游刃有余。

想继续深挖哪个部分？

• BeanPostProcessor 源码级解析
• 循环依赖完整流程图
• 如何在 Spring Boot 中实现全局 Bean 销毁钩子
• 还是直接给你一个“带完整生命周期日志的 Starter 项目”？

告诉我，我立刻继续陪你拆！