Bean 生命周期：从实例化到销毁的完整流程

// 路径 1：Supplier 创建（@Bean 方法返回的 Supplier）
if (mbd.getInstanceSupplier() != null) {
    instanceSupplier = mbd.getInstanceSupplier();
}

// 路径 2：工厂方法（@Bean 标注的方法 或 factory-method）
if (mbd.getFactoryMethodName() != null) {
    return instantiateUsingFactoryMethod(beanName, mbd, args);
}

// 路径 3：构造函数（最常见的方式）
// 如果只有默认无参构造 → 直接 newInstance()
// 如果有多个构造器 → Spring 会选择"最贪婪"的那个
// 即参数最多、且参数类型都能在容器中找到 Bean 的那个构造器
return autowireConstructor(beanName, mbd, ctor, args);

public class OrderService {

    // @Autowired — Spring 提供，按类型注入，多个候选时用 @Qualifier
    // 默认 required=true，找不到 Bean 会抛异常
    @Autowired
    private PaymentService paymentService;

    // @Value — 注入配置值、SpEL 表达式、字面量
    @Value("${app.max-retry:3}")   // 带默认值的配置项
    private int maxRetry;

    // @Resource — JSR-250 标准，默认按名称注入
    // name 属性匹配 Bean 名称，找不到再按类型 fallback
    @Resource(name = "smsSender")
    private MessageSender messageSender;
}

protected Object initializeBean(String beanName, Object bean,
                                 RootBeanDefinition mbd) {

    // —— 步骤 ⑥⑦⑧：Aware 回调 ——
    invokeAwareMethods(beanName, bean);

    // —— 步骤 ⑨：BPP 前置处理 ——
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(
                      wrappedBean, beanName);

    // —— 步骤 ⑩⑪⑫：初始化回调 ——
    invokeInitMethods(beanName, wrappedBean, mbd);

    // —— 步骤 ⑬：BPP 后置处理（AOP 代理在此创建）——
    wrappedBean = applyBeanPostProcessorsAfterInitialization(
                      wrappedBean, beanName);

    return wrappedBean;
}

public void destroy() {
    // D1. @PreDestroy — JSR-250 标准，最先执行
    // 由 InitDestroyAnnotationBeanPostProcessor 触发
    invokeCustomDestroyMethod(this.destroyMethod);

    // D2. DisposableBean.destroy() — Spring 接口回调
    if (this.bean instanceof DisposableBean) {
        ((DisposableBean) this.bean).destroy();
    }

    // D3. destroy-method — 自定义销毁方法
    // 通过 @Bean(destroyMethod="cleanup") 指定
    invokeCustomDestroyMethod(this.destroyMethodName);
}

@Component
public class CacheManager implements
        BeanNameAware, InitializingBean, DisposableBean {

    private String beanName;
    private ConcurrentHashMap<String, Object> cache;

    // 步骤 ⑥：Aware 回调
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        log.info("[⑥] BeanNameAware: " + name);
    }

    // 步骤 ⑩：@PostConstruct
    @PostConstruct
    public void postConstruct() {
        log.info("[⑩] @PostConstruct");
    }

    // 步骤 ⑪：InitializingBean
    @Override
    public void afterPropertiesSet() {
        this.cache = new ConcurrentHashMap<>();
        log.info("[⑪] afterPropertiesSet: 缓存初始化完成");
        loadHotData();  // 缓存预热
    }

    // 步骤 ⑫：init-method
    public void customInit() {
        log.info("[⑫] init-method: customInit()");
    }

    // D1：@PreDestroy
    @PreDestroy
    public void preDestroy() {
        log.info("[D1] @PreDestroy: 准备清理");
    }

    // D2：DisposableBean
    @Override
    public void destroy() {
        cache.clear();
        log.info("[D2] DisposableBean.destroy: 缓存已清空");
    }
}