Spring Bean生命周期

引言

Spring框架的核心能力之一是Bean的生命周期管理。通过容器对Bean的创建、初始化、使用到销毁的全生命周期进行管控，可以专注于业务逻辑，而无需手动处理对象的创建与资源释放。

---

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

Spring官方文档将Bean生命周期划分为实例化→属性注入→初始化→销毁 四大阶段，但实际底层实现远比这复杂。通过分析AbstractApplicationContext.refresh()方法的源码（Spring容器启动的核心流程），我们可以将完整的生命周期拆解为以下7个关键阶段（对应LifeCycleBean类中的7个标记点）：

graph TD A[容器启动] --> B[实例化阶段] B --> C[1. 构造器调用] C --> D[2. 实例化后回调 InstantiationAwareBeanPostProcessor] D --> E{是否返回自定义实例?} E -->|是| F[使用自定义实例] E -->|否| G[原始实例] G --> H[3. 依赖注入前 BeanPostProcessor.postProcessProperties前] H --> I[4. Aware接口回调 BeanFactoryAware/ApplicationContextAware] I --> J[5. 依赖注入阶段 Autowired/Value] J --> K[6. 初始化前回调 BeanPostProcessor.postProcessBeforeInitialization] K --> L[7. InitializingBean.afterPropertiesSet] L --> M[8. PostConstruct初始化] M --> N[9. 初始化后回调 BeanPostProcessor.postProcessAfterInitialization] N --> O{是否 AOP 增强?} O -->|是| P[生成 AOP 代理对象] O -->|否| Q[原始 Bean 对象] P --> R[Bean 就绪可用状态] Q --> R R --> S[应用运行 Bean 被使用] S --> T[容器关闭] T --> U[销毁前回调 DestructionAwareBeanPostProcessor.postProcessBeforeDestruction] U --> V[10. DisposableBean.destroy] V --> W[11. destroy-method XML/Bean指定 ] W --> X[12. PreDestroy销毁] X --> Y[Bean 销毁完成] %% 扩展点标注 虚线框 classDef ext fill:#f9f,stroke:#333,stroke-width:1px D -.->|InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation| D I -.->|BeanFactoryAware.setBeanFactory/ApplicationContextAware.setApplicationContext | I K -.->|BeanPostProcessor.postProcessBeforeInitialization| K M -.->|CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization| M N -.->|BeanPostProcessor.postProcessAfterInitialization| N O -.->|AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization| O U -.->|DestructionAwareBeanPostProcessor.postProcessBeforeDestruction| U X -.->|CommonAnnotationBeanPostProcessor.invokeCustomDestroyMethod| X %% 样式定义 classDef note fill:#fff3cd,stroke:#ffc107 class C,C1,I,I1,K,M,N,O,U,W,W1 note

---

二、阶段一：实例化（Constructor）

2.1 触发时机

当容器需要获取一个Bean实例时（如首次调用context.getBean()），会触发该Bean的实例化过程。

2.2 底层源码解析

核心逻辑位于AbstractAutowireCapableBeanFactory的createBeanInstance()方法：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // ... 省略参数校验逻辑
    return instantiateBean(beanName, mbd);
}

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        if (mbd.getFactoryMethodName() != null) {
            // 工厂方法实例化
            beanInstance = invokeFactoryMethod(beanName, mbd, args);
        } else {
            // 构造器实例化（重点）
            BeanUtils.instantiateClass(constructorToUse); 
        }
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    } catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
}

通过BeanUtils.instantiateClass()方法反射调用构造器，创建Bean的原始实例。此时，Bean的成员变量尚未初始化，仅完成内存分配和构造器执行。

2.3 日志验证

在LifeCycleBean的构造器中添加日志：

public LifeCycleBean() {
    log.info("[阶段1] 构造器调用（内存地址：{}）...", beanId);
}

启动容器时，控制台会输出：

[阶段1] 构造器调用（内存地址：3d4e405e）- 源码位置：AbstractAutowireCapableBeanFactory.createBeanInstance()

这说明构造器是生命周期的第一个阶段。

---

三、阶段二：依赖注入（Autowired/Value）

3.1 触发时机

实例化完成后，容器需要为Bean注入依赖的属性（如@Autowired标注的字段、@Value注入的外部属性）。

3.2 底层源码解析

依赖注入的核心逻辑在populateBean()方法中，该方法会调用AutowiredAnnotationBeanPostProcessor处理注解注入：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // ... 省略属性值解析逻辑
    if (hasInstAwareBpps) {
        // 遍历所有Aware接口后置处理器（如BeanFactoryAware）
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                ((InstantiationAwareBeanPostProcessor) bp).postProcessAfterInstantiation(bw.getWrappedInstance(), beanName);
            }
        }
    }
    // 处理@Autowired/@Value注入（关键）
    applyPropertyValues(beanName, mbd, bw, pvs);
}

其中，applyPropertyValues()方法会解析PropertyValues（包含@Value的属性值），并通过反射设置到Bean实例中。对于@Autowired注解，实际由AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法处理。

3.3 日志验证

在LifeCycleBean中添加依赖注入阶段的方法：

@Autowired
public void autowire(@Value("${JAVA_HOME}") String home) {
    log.info("[阶段2] 依赖注入完成（JAVA_HOME={}）...", home);
}

启动日志显示：

[阶段2] 依赖注入完成（JAVA_HOME=G:\DevelopmentSoftware\JAVA-17）- 源码位置：AutowiredAnnotationBeanPostProcessor.postProcessProperties()

此时，JAVA_HOME属性已被成功注入。

---

四、阶段三：初始化前（BeanPostProcessor）

4.1 触发时机

依赖注入完成后，容器会调用所有BeanPostProcessor的postProcessBeforeInitialization()方法，允许开发者对Bean进行预处理（如AOP增强前的修改）。

4.2 核心扩展点：BeanPostProcessor

BeanPostProcessor是Spring提供的核心扩展接口，包含两个关键方法：

• postProcessBeforeInitialization()：初始化前调用（阶段3）
• postProcessAfterInitialization()：初始化后调用（阶段5）

4.3 自定义BeanPostProcessor示例

在MyBeanPostConstruct类中实现了InstantiationAwareBeanPostProcessor（继承自BeanPostProcessor），其postProcessAfterInstantiation()方法会在实例化后立即执行：

@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) {
    if ("lifeCycleBean".equals(beanName)) {
        log.info("实例化后（Bean实例：{}）...", bean);
    }
    return true; // 返回true表示继续执行依赖注入
}

该方法的执行时机介于实例化完成 和依赖注入开始之间，可用于对原始Bean实例进行修改（如动态代理的前置准备）。

4.4 日志验证

启动日志中会出现：

实例化后（Bean实例：com.dwl.bean_life_cycle.LifeCycleBean@3d4e405e）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()

这验证了实例化后回调的执行顺序。

---

五、阶段四：@PostConstruct初始化

5.1 触发时机

依赖注入完成后，容器会调用@PostConstruct注解标注的方法，用于执行Bean的自定义初始化逻辑（如在对象完全构造后加载配置、连接数据库等）。

5.2 底层实现：CommonAnnotationBeanPostProcessor

@PostConstruct的支持由CommonAnnotationBeanPostProcessor（Spring 2.5+引入）提供，其postProcessBeforeInitialization()方法会检测@PostConstruct注解并执行：

public Object postProcessBeforeInitialization(Object bean, String beanName) {
    // ... 省略其他逻辑
    if (mbd != null && bean != null) {
        invokeInitMethods(bean, beanName, mbd);
    }
    return bean;
}

private void invokeInitMethods(Object bean, String beanName, @Nullable RootBeanDefinition mbd) {
    // 先执行InitializingBean.afterPropertiesSet()
    if (bean instanceof InitializingBean) {
        ((InitializingBean) bean).afterPropertiesSet();
    }
    // 再执行@PostConstruct
    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null) {
            invokeCustomInitMethod(bean, beanName, initMethodName);
        }
    }
    // 关键：执行@PostConstruct
    if (bean != null) {
        postProcessBeforeInitialization(bean, beanName);
    }
}

注意：@PostConstruct的执行优先级高于InitializingBean.afterPropertiesSet()和自定义init-method。

5.3 日志验证

在LifeCycleBean中添加@PostConstruct方法：

@PostConstruct
public void postConstruct() {
    log.info("[阶段4] @PostConstruct初始化...");
}

启动日志显示：

[阶段4] @PostConstruct初始化- 源码位置：CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization()

此时，Bean已完成基础初始化，可以安全地使用依赖注入的资源。

---

六、阶段五：初始化后（AOP增强）

6.1 触发时机

@PostConstruct执行完成后，容器会调用BeanPostProcessor的postProcessAfterInitialization()方法。对于AOP场景，AnnotationAwareAspectJAutoProxyCreator会在此阶段对符合条件的Bean生成代理对象。

6.2 AOP增强的核心逻辑

AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization()方法会判断Bean是否需要被代理（通过@AspectJ注解或XML配置），如果需要则生成代理对象并返回：

public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null && isInfrastructureBean(beanName)) {
        return bean;
    }
    // 生成代理对象的关键逻辑
    return wrapIfNecessary(bean, beanName, cacheKey);
}

生成的代理对象会拦截目标方法，实现AOP的核心功能（如日志记录、事务管理）。

6.3 日志验证

在MyBeanPostConstruct中添加postProcessAfterInitialization()方法：

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if ("lifeCycleBean".equals(beanName)) {
        log.info("初始化后（AOP代理生成前）...");
    }
    return bean;
}

启动日志显示：

初始化后（AOP代理生成前）- 源码位置：BeanPostProcessor.postProcessAfterInitialization()

此时，若Bean被AOP增强，后续获取的将是代理对象（可通过System.identityHashCode()验证内存地址是否变化）。

---

七、阶段六：销毁前（@PreDestroy）

7.1 触发时机

当容器关闭时（调用ConfigurableApplicationContext.close()），会对所有单例Bean执行销毁逻辑。@PreDestroy注解标注的方法会在Bean销毁前执行，用于释放资源（如关闭数据库连接、停止定时任务）。

7.2 底层源码解析

销毁流程的核心在AbstractApplicationContext.close()方法，最终会调用DefaultSingletonBeanRegistry.destroySingletons()：

public void destroySingletons() {
    // ... 省略其他逻辑
    for (String beanName : new ArrayList<>(this.singletonObjects.keySet())) {
        destroySingleton(beanName);
    }
}

protected void destroySingleton(String beanName) {
    // ... 省略Bean移除逻辑
    destroyBean(beanName, getSingleton(beanName), getBeanDefinition(beanName));
}

protected void destroyBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 调用DisposableBean.destroy()
    if (bean instanceof DisposableBean) {
        ((DisposableBean) bean).destroy();
    }
    // 调用@PreDestroy
    invokeCustomDestroyMethod(bean, beanName);
    // 调用自定义DestructionAwareBeanPostProcessor
    for (DestructionAwareBeanPostProcessor processor : getDestructionAwareBeanPostProcessors()) {
        processor.postProcessBeforeDestruction(bean, beanName);
    }
}

7.3 日志验证

在LifeCycleBean中添加@PreDestroy方法：

@PreDestroy
public void preDestroy() {
    log.info("[阶段6] @PreDestroy销毁前...");
}

关闭容器时，日志显示：

[阶段6] @PreDestroy销毁前- 源码位置：DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()

---

八、阶段七：销毁（DisposableBean/destroy-method）

8.1 触发时机

@PreDestroy执行完成后，容器会调用DisposableBean.destroy()方法（若Bean实现了该接口）或destroy-method指定的方法（XML配置或@Bean(destroyMethod=...)），用于执行最终的资源释放操作。

8.2 自定义销毁逻辑

在LifeCycleBean中添加销毁方法：

public void destroy() {
    log.info("[阶段7] Bean销毁（内存地址：{}）...", beanId);
}

并在配置类中声明（或在XML中配置）：

@Bean(destroyMethod = "destroy")
public LifeCycleBean lifeCycleBean() {
    return new LifeCycleBean();
}

8.3 日志验证

关闭容器时，日志显示：

[阶段7] Bean销毁（内存地址：1b6d3586）- 源码位置：AbstractAutowireCapableBeanFactory.destroyBean()

此时，Bean的所有资源已被释放，无法再被容器管理。

---

九、自定义BeanPostProcessor的深度影响

在之前的代码中，我们实现了一个MyBeanPostConstruct类，同时实现了InstantiationAwareBeanPostProcessor和DestructionAwareBeanPostProcessor。通过分析其回调方法的执行顺序，可以更清晰地理解Spring的扩展点机制：

阶段	方法	执行时机
实例化前	postProcessBeforeInstantiation()	反射调用构造器前
实例化后	postProcessAfterInstantiation()	构造器执行完成后（依赖注入前）
依赖注入前	postProcessProperties()	处理@Autowired/@Value前
初始化前	postProcessBeforeInitialization()	@PostConstruct前
初始化后	postProcessAfterInitialization()	@PostConstruct后（AOP增强前）
销毁前	postProcessBeforeDestruction()	@PreDestroy后

通过自定义这些方法，开发者可以实现：

• 动态代理（如AOP）
• 属性值的动态修改（如加密字段解密）
• Bean的延迟初始化（如@Lazy注解的支持）
• 资源的预释放（如销毁前的缓存清理）

---

十、实验验证：完整生命周期日志

通过运行BeanLifeCycleCase的main方法，观察完整日志输出，验证生命周期阶段的顺序：

5-06-13T13:24:33.136+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 实例化前（Bean名称：lifeCycleBean）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
2025-06-13T13:24:33.142+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段1] 构造器调用（内存地址：3d4e405e）- 源码位置：AbstractAutowireCapableBeanFactory.createBeanInstance()
2025-06-13T13:24:33.144+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 实例化后（Bean实例：com.dwl.bean_life_cycle.LifeCycleBean@3d4e405e）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
2025-06-13T13:24:33.144+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 依赖注入阶段（原始属性值：PropertyValues: length=0）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessProperties()
2025-06-13T13:24:33.145+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段2] 依赖注入完成（JAVA_HOME=G:\DevelopmentSoftware\JAVA-17）- 源码位置：AutowiredAnnotationBeanPostProcessor.postProcessProperties()
2025-06-13T13:24:33.145+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 初始化前（@PostConstruct前）- 源码位置：BeanPostProcessor.postProcessBeforeInitialization()
2025-06-13T13:24:33.145+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段4] @PostConstruct初始化- 源码位置：CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization()
2025-06-13T13:24:36.999+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段5] 初始化后（AOP代理生成前）- 源码位置：BeanPostProcessor.postProcessAfterInitialization()
2025-06-13T13:24:36.999+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 初始化后（AOP代理生成前）- 源码位置：BeanPostProcessor.postProcessAfterInitialization()
2025-06-13T13:24:37.271+08:00  INFO 66400 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 9527 (http) with context path '/'
2025-06-13T13:24:37.278+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : Started BeanLifeCycleCase in 5.925 seconds (process running for 6.822)
2025-06-13T13:24:37.280+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : 容器启动完成，耗时：6058ms（对应preInstantiateSingletons()实例化单例Bean）
2025-06-13T13:24:37.281+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : 上下文已准备就绪，触发Bean生命周期演示（对应BeanFactory.getBean()）
2025-06-13T13:24:37.281+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : 手动获取Bean实例：com.dwl.bean_life_cycle.LifeCycleBean@3d4e405e
2025-06-13T13:24:37.281+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : 开始关闭容器（触发destroyBeans()）
2025-06-13T13:24:37.370+08:00  INFO 66400 --- [           main] c.d.bean_life_cycle.MyBeanPostConstruct  : 销毁前（@PreDestroy后）- 源码位置：DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
2025-06-13T13:24:37.370+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段6] @PreDestroy销毁前- 源码位置：DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
2025-06-13T13:24:37.370+08:00  INFO 66400 --- [           main] com.dwl.bean_life_cycle.LifeCycleBean    : [阶段7] Bean销毁（内存地址：3d4e405e）- 源码位置：AbstractAutowireCapableBeanFactory.destroyBean()
2025-06-13T13:24:37.378+08:00  INFO 66400 --- [           main] c.dwl.bean_life_cycle.BeanLifeCycleCase  : 容器关闭完成
Disconnected from the target VM, address: '127.0.0.1:14989', transport: 'socket'

Process finished with exit code 0

---

十一、总结

Spring Bean的生命周期是理解Spring框架的核心之一。通过本文的深入解析，我们了解到：

1. 生命周期的7个阶段：构造器→实例化后→依赖注入→初始化前（@PostConstruct前）→@PostConstruct→初始化后（AOP增强前）→销毁前（@PreDestroy后）→销毁。
2. 核心扩展点 ：BeanPostProcessor（尤其是InstantiationAwareBeanPostProcessor和DestructionAwareBeanPostProcessor）允许开发者深度干预Bean的创建和销毁过程。
3. 源码驱动 ：通过分析AbstractAutowireCapableBeanFactory、CommonAnnotationBeanPostProcessor等核心类的源码，可以更清晰地理解各阶段的触发机制。
4. 实践价值：掌握生命周期有助于解决依赖注入异常、AOP增强失效、资源未正确释放等问题，是高级Spring开发者的必备技能。

理解Spring Bean的生命周期，不仅能让我们更高效地使用框架，还能在遇到问题时快速定位根源，真正做到"知其然，更知其所以然"。

完整代码

package com.dwl.bean_life_cycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * @ClassName BeanLifeCycleCase
 * @Description Spring Bean生命周期演示主类
 * @Version 1.0.0
 * @Date 2025
 * @Author By Dwl
 */
@Slf4j
@SpringBootApplication(scanBasePackages = {"com.dwl.bean_life_cycle"})
public class BeanLifeCycleCase {
    public static void main(String[] args) {
        log.info("进入Spring Boot启动入口：SpringApplication.run()");
        long startTime = System.currentTimeMillis();

        // 模拟Spring容器启动核心流程（对应AbstractApplicationContext.refresh()）
        ConfigurableApplicationContext context = SpringApplication.run(BeanLifeCycleCase.class, args);

        log.info("容器启动完成，耗时：{}ms（对应preInstantiateSingletons()实例化单例Bean）",
                System.currentTimeMillis() - startTime);
        log.info("上下文已准备就绪，触发Bean生命周期演示（对应BeanFactory.getBean()）");

        // 手动触发Bean的初始化（模拟应用运行中访问Bean）
        LifeCycleBean bean = context.getBean(LifeCycleBean.class);
        log.info("手动获取Bean实例：{}", bean);

        // 模拟容器关闭（对应AbstractApplicationContext.close()）
        log.info("开始关闭容器（触发destroyBeans()）");
        context.close();
        log.info("容器关闭完成");
    }

}


package com.dwl.bean_life_cycle;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @ClassName LifeCycleBean
 * @Description 演示Spring Bean完整生命周期的标准Bean
 * @Version 1.0.0
 * @Date 2025
 * @Author By Dwl
 */
@Slf4j
@Component("lifeCycleBean")
public class LifeCycleBean implements InitializingBean, DisposableBean {

    // 记录Bean实例的内存地址（用于追踪不同阶段）
    private final String beanId = Integer.toHexString(System.identityHashCode(this));

    /**
     * 1. 构造器阶段（对应AbstractAutowireCapableBeanFactory.createBeanInstance()）
     * 源码调用链：createBean() → doCreateBean() → createBeanInstance() → 反射调用构造器
     */
    public LifeCycleBean() {
        log.info("[阶段1] 构造器调用（内存地址：{}）- 源码位置：AbstractAutowireCapableBeanFactory.createBeanInstance()", beanId);
    }

    /**
     * 2. 依赖注入阶段（对应AutowiredAnnotationBeanPostProcessor.postProcessProperties()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsBeforeInitialization() → postProcessProperties()
     *
     * @param home 通过@Value注入的系统属性
     */
    @Autowired
    public void autowire(@Value("${JAVA_HOME}") String home) {
        log.info("[阶段2] 依赖注入完成（JAVA_HOME={}）- 源码位置：AutowiredAnnotationBeanPostProcessor.postProcessProperties()", home);
    }

    /**
     * 3. 初始化前阶段（对应BeanPostProcessor.postProcessBeforeInitialization()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsBeforeInitialization()
     * PostConstruct注解：在方法上添加`@PostConstruct`，Spring会在依赖注入完成后优先调用此方法（早于@PostConstruct注解的其他方法）。
     */
    @PostConstruct
    public void beforeInit() {
        log.info("[阶段3] 初始化前（@PostConstruct前）- 源码位置：BeanPostProcessor.postProcessBeforeInitialization()");
    }

    /**
     * 4. @PostConstruct初始化（对应CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsBeforeInitialization() → @PostConstruct注解方法
     */
    @PostConstruct
    public void postConstruct() {
        log.info("[阶段4] @PostConstruct初始化- 源码位置：CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization()");
    }

    /**
     * 5. 初始化后阶段（对应BeanPostProcessor.postProcessAfterInitialization()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsAfterInitialization()
     */
    @Override
    public void afterPropertiesSet() {
        log.info("[阶段5] 初始化后（AOP代理生成前）- 源码位置：BeanPostProcessor.postProcessAfterInitialization()");
    }

    /**
     * 6. 销毁前阶段（对应DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()）
     * 源码调用链：destroyBean() → applyBeanPostProcessorsBeforeDestruction()
     */
    @PreDestroy
    public void preDestroy() {
        log.info("[阶段6] @PreDestroy销毁前- 源码位置：DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()");
    }

    /**
     * 7. 销毁阶段（对应DisposableBean.destroy()或destroy-method）
     * 源码调用链：destroyBean() → 调用DisposableBean.destroy()或反射调用destroy-method
     */
    @Override
    public void destroy() {
        log.info("[阶段7] Bean销毁（内存地址：{}）- 源码位置：AbstractAutowireCapableBeanFactory.destroyBean()", beanId);
    }

}


package com.dwl.bean_life_cycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @ClassName MyBeanPostConstruct
 * @Description 自定义Bean后处理器
 * @Version 1.0.0
 * @Date 2025
 * @Author By Dwl
 */
@Slf4j
@Component
public class MyBeanPostConstruct implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

    /**
     * 1. 实例化前回调（对应AbstractAutowireCapableBeanFactory.createBeanInstance()）
     * 源码调用链：createBeanInstance() → postProcessBeforeInstantiation()（返回null时不替换实例）
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("实例化前（Bean名称：{}）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()", beanName);
        }
        return null; // 返回null表示不替换默认实例化
    }

    /**
     * 2. 实例化后回调（对应AbstractAutowireCapableBeanFactory.doCreateBean()）
     * 源码调用链：doCreateBean() → postProcessAfterInstantiation()（依赖注入前）
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("实例化后（Bean实例：{}）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()", bean);
        }
        return true; // 返回true表示继续执行依赖注入
    }

    /**
     * 3. 依赖注入阶段回调（对应AutowiredAnnotationBeanPostProcessor.postProcessProperties()）
     * 源码调用链：postProcessProperties() → 处理@Autowired/@Value注入
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("依赖注入阶段（原始属性值：{}）- 源码位置：InstantiationAwareBeanPostProcessor.postProcessProperties()", pvs);
        }
        return pvs; // 返回原始属性值（未修改）
    }

    /**
     * 4. 初始化前回调（对应CommonAnnotationBeanPostProcessor.postProcessBeforeInitialization()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsBeforeInitialization()
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("初始化前（@PostConstruct前）- 源码位置：BeanPostProcessor.postProcessBeforeInitialization()");
        }
        return bean; // 返回原始实例（未替换）
    }

    /**
     * 5. 初始化后回调（对应AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization()）
     * 源码调用链：initializeBean() → applyBeanPostProcessorsAfterInitialization()
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("初始化后（AOP代理生成前）- 源码位置：BeanPostProcessor.postProcessAfterInitialization()");
        }
        return bean; // 返回原始实例（未替换）
    }

    /**
     * 6. 销毁前回调（对应AbstractAutowireCapableBeanFactory.destroyBean()）
     * 源码调用链：destroyBean() → applyBeanPostProcessorsBeforeDestruction()
     */
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if ("lifeCycleBean".equals(beanName)) {
            log.info("销毁前（@PreDestroy后）- 源码位置：DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()");
        }
    }

}