Skip to content

3.1-2 Bean 生命周期与扩展点全景 ​

所属:03 主流框架 / 3.1 Spring 分级:A 状态:◐ 初稿 关联:3.1-1、3.1-3、3.1-4、3.1-5、3.1-6、3.1-7、3.1-10、3.1-11、3.2-1

  • 题型:流程 / 原理 / 扩展点

  • 一句话结论:Spring Bean 的生命周期是 BeanDefinition → 实例化 → 属性注入 → 初始化 → 使用 → 销毁;真正可扩展的骨架是 BeanFactoryPostProcessor 在定义阶段改 BeanDefinition,BeanPostProcessor 在实例化/初始化前后改 Bean 实例。初始化顺序是 @PostConstruct → InitializingBean.afterPropertiesSet → init-method,销毁顺序是 @PreDestroy → DisposableBean.destroy → destroy-method;AOP 代理在初始化后由 BPP 生成,循环依赖靠三级缓存/early reference。

  • 分层要点:

    1. 定义阶段不是“Bean 生命周期”但决定后面一切:BeanDefinition 保存 class、scope、lazy、depends-on、构造参数、属性、init/destroy 方法、factory-method 等;BeanFactoryPostProcessor/BeanDefinitionRegistryPostProcessor 在这一阶段修改或注册定义。ConfigurationClassPostProcessor 解析 @Configuration/@ComponentScan/@Bean 也在这里(3.1-1 第 5 步)。
    2. 实例化前可以短路:InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 可以返回一个代理/对象,直接跳过常规实例化、属性注入和初始化;Spring 之后仍会执行 postProcessAfterInitialization。AOP 的常规代理不在这里做,而是在初始化后。
    3. 实例化与属性注入:createBeanInstance 走 Supplier、工厂方法或构造器(determineCandidateConstructors 选构造器);MergedBeanDefinitionPostProcessor 在实例化后缓存注入元数据;populateBean 先 postProcessAfterInstantiation(返回 false 可跳过属性填充),再 postProcessProperties 完成 @Autowired/@Resource/@Value 注入,最后应用属性值。
    4. 初始化阶段:invokeAwareMethods 先回调 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware;ApplicationContextAwareProcessor 等 BPP 再回调 EnvironmentAware、ResourceLoaderAware、ApplicationContextAware 等;随后 BPP before 执行 @PostConstruct,invokeInitMethods 执行 afterPropertiesSet 和自定义 init-method,最后 BPP after 生成 AOP 代理。
    5. 使用阶段:非懒加载单例在 finishBeanFactoryInitialization 的 preInstantiateSingletons 中创建;所有单例完成后回调 SmartInitializingSingleton.afterSingletonsInstantiated;FactoryBean 的 getObject() 产品通常也会经过 BPP after(synthetic 定义除外);prototype 每次 getBean 新建,容器不缓存。
    6. 销毁阶段:容器关闭时发布 ContextClosedEvent,LifecycleProcessor.onClose 停止 SmartLifecycle,再销毁单例;顺序是 DestructionAwareBeanPostProcessor(@PreDestroy)→ DisposableBean.destroy → 自定义 destroy-method,依赖者先于被依赖者销毁。prototype 的销毁不由容器管理,kill -9 也不会执行销毁回调。
    7. 扩展点坐标:定义阶段 BFPP/RegistryPostProcessor;实例化前 InstantiationAwareBPP.postProcessBeforeInstantiation;属性注入 postProcessAfterInstantiation/postProcessProperties;初始化前后 BeanPostProcessor;销毁 DestructionAwareBeanPostProcessor;另有 MergedBeanDefinitionPostProcessor、SmartInstantiationAwareBeanPostProcessor、Aware、InitializingBean/DisposableBean、@PostConstruct/@PreDestroy、init-method/destroy-method、FactoryBean、SmartInitializingSingleton、SmartLifecycle。
    8. 常见失效与排查:@PostConstruct 自调用 @Transactional/@Async 不生效(代理还没生成或自调用绕过代理);@PreDestroy 在 prototype/kill -9 下不执行;自定义 BPP 顺序错会让注入/代理异常;BPP 返回 null 会提前结束后续 BPP 链;@Bean 会推断 close/shutdown 作为 destroy-method;Boot 2.6+ 默认禁止循环依赖。
  • 图/流程:

text
Bean 生命周期主链:
  BeanDefinition(解析/注册/修改)
    → postProcessBeforeInstantiation(可短路)
    → createBeanInstance(Supplier/工厂/构造器)
    → MergedBeanDefinitionPostProcessor(缓存注入元数据)
    → 暴露 early reference(循环依赖时)
    → populateBean(属性注入)
    → invokeAwareMethods(BeanName/ClassLoader/BeanFactory)
    → BPP before(ApplicationContextAware、@PostConstruct 等)
    → afterPropertiesSet
    → init-method
    → BPP after(AOP 代理)
    → 单例池 / 使用
    → @PreDestroy
    → DisposableBean.destroy
    → destroy-method
text
BPP 插入点:
  beforeInstantiation → instantiate → populate → beforeInit → init → afterInit
        ↑                  ↑            ↑            ↑                    ↑
  InstantiationAware  构造器选择   属性注入      @PostConstruct        AOP/代理
text
三级缓存与 early reference:
  A 实例化
    → addSingletonFactory(A, () -> getEarlyBeanReference(A))
    → populate A,发现依赖 B
      → B 实例化,populate B,发现依赖 A
        → getSingleton(A, allowEarlyReference=true)
          → singletonFactories 取 A 的 ObjectFactory
          → getEarlyBeanReference:必要时提前创建 AOP 代理
          → 放入 earlySingletonObjects
      → B 完成初始化
    → A 继续 populate/初始化
text
销毁链:
  context.close()
    → 发布 ContextClosedEvent
    → LifecycleProcessor.onClose(SmartLifecycle.stop)
    → destroySingletons
      → 先销毁 dependent beans
      → DestructionAwareBeanPostProcessor(@PreDestroy)
      → DisposableBean.destroy()
      → 自定义 destroy-method
text
作用域:
  singleton  → 容器内一个实例,容器管理销毁
  prototype  → 每次 getBean 新建,容器不管理销毁
  request    → 每个 HTTP 请求一个
  session    → 每个 Session 一个
  application→ 每个 ServletContext 一个
  websocket  → 每个 WebSocket 会话一个
  • 版本/源码锚点:

    • Spring Framework 5.3.x / 6.x:AbstractAutowireCapableBeanFactory#createBean/doCreateBean/createBeanInstance/populateBean/initializeBean/invokeInitMethods;AbstractBeanFactory#getBean/doGetBean;DefaultSingletonBeanRegistry#getSingleton/addSingletonFactory/destroySingletons;DisposableBeanAdapter#destroy。
    • 关键扩展点:InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor、DestructionAwareBeanPostProcessor、BeanPostProcessor。
    • 关键实现:AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、AnnotationAwareAspectJAutoProxyCreator、ApplicationContextAwareProcessor、ServletContextAwareProcessor。
    • Spring 6 / Boot 3:@PostConstruct/@PreDestroy 使用 jakarta.annotation;Boot 3 要求 Java 17+、Spring 6、Jakarta EE 9+。
    • Boot 2.6+:spring.main.allow-circular-references 默认 false,循环依赖默认启动失败;2.5 及以前默认允许。
    • 其他:@Configuration(proxyBeanMethods=false) 5.2+;@Bean(destroyMethod="") 可关闭推断;postProcessProperties 优先于已废弃的 postProcessPropertyValues。
  • 生命周期阶段与扩展点:

阶段关键动作扩展点备注
定义解析/注册/合并 BeanDefinitionBeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor不创建实例
实例化前resolveBeforeInstantiationInstantiationAwareBPP.postProcessBeforeInstantiation返回非 null 可短路
实例化构造器/工厂/SupplierSmartInstantiationAwareBPP.determineCandidateConstructors构造器循环依赖在此暴露
合并定义缓存注入/生命周期元数据MergedBeanDefinitionPostProcessor实例化后、注入前
early reference暴露三级缓存工厂SmartInstantiationAwareBPP.getEarlyBeanReference解决 setter 循环依赖
属性注入populateBeanInstantiationAwareBPP.postProcessAfterInstantiation/postProcessProperties@Autowired/@Resource/@Value
Aware回调容器能力Aware + ApplicationContextAwareProcessor3 个在 invokeAwareMethods
初始化前BPP beforeBeanPostProcessor.postProcessBeforeInitialization@PostConstruct 在这里
初始化afterPropertiesSet、init-methodInitializingBean、@Bean(initMethod)顺序固定
初始化后BPP afterBeanPostProcessor.postProcessAfterInitializationAOP 代理在这里
使用单例池/原型新建SmartInitializingSingleton所有单例后回调
销毁关闭容器DestructionAwareBeanPostProcessor、DisposableBean、destroy-method依赖者先销毁
  • 初始化/销毁顺序:
顺序初始化销毁
1@PostConstruct(BPP before)@PreDestroy(DestructionAwareBPP)
2InitializingBean.afterPropertiesSet()DisposableBean.destroy()
3自定义 init-method自定义 destroy-method

记忆:注解 → 接口 → 配置;初始化从小到大,销毁同样从注解到配置。

  • 扩展点全景:
扩展点作用阶段典型用途注意
BeanFactoryPostProcessor定义改 BeanDefinition、占位符不能代理 Bean
BeanDefinitionRegistryPostProcessor定义扫描/注册 BeanDefinitionBFPP 子类型,最先执行
InstantiationAwareBeanPostProcessor实例化/注入短路创建、属性注入三个方法各有边界
SmartInstantiationAwareBeanPostProcessor实例化/循环依赖选构造器、early referenceAOP 早期代理
MergedBeanDefinitionPostProcessor实例化后缓存注入元数据@Autowired 元数据
BeanPostProcessor初始化前后代理、校验、埋点顺序敏感
DestructionAwareBeanPostProcessor销毁前@PreDestroy只对容器管理的 Bean
Aware初始化前拿容器/环境/资源能用构造器注入就别用
InitializingBean/DisposableBean初始化/销毁资源打开/关闭与注解/配置可叠加
FactoryBean使用创建复杂对象产品生命周期特殊
SmartInitializingSingleton所有单例后缓存预热、校验只非懒加载单例
SmartLifecycle容器刷新/关闭启停后台线程有 phase/autoStartup
  • 注入注解对比:
注解处理器解析规则备注
@AutowiredAutowiredAnnotationBeanPostProcessor先类型,再 @Qualifier/名称可构造器/字段/方法;required=false
@Qualifier同上缩小候选与 @Autowired 配合
@Value同上占位符/SpEL依赖 Environment/占位符解析
@ResourceCommonAnnotationBeanPostProcessor先名称,再类型JSR-250;Boot 3 用 jakarta.annotation
@InjectAutowiredAnnotationBeanPostProcessorJSR-330,按类型需对应 API
@PostConstructCommonAnnotationBeanPostProcessor初始化前必须无参、返回 void
@PreDestroy同上(DestructionAware)销毁前prototype 不执行
  • 作用域对比:
作用域实例数销毁管理典型场景
singleton每容器一个容器无状态服务、配置
prototype每次 getBean 一个不管理有状态/短生命周期
request每请求一个Web 作用域请求上下文
session每会话一个Web 作用域用户会话
application每 ServletContext 一个Web 作用域全局缓存
websocket每 WebSocket 会话一个Web 作用域长连接
  • 常见失败与定位:
现象常见原因处理
BeanCurrentlyInCreationException构造器循环依赖/@DependsOn 环改 setter/@Lazy/ObjectProvider,重构
UnsatisfiedDependencyException缺 Bean/Qualifier 不匹配补定义、@Qualifier、@Primary
NoUniqueBeanDefinitionException同类型多候选@Primary/@Qualifier/按名注入
BeanDefinitionOverrideException同名 Bean 重复注册改名/排除/谨慎开 overriding
BeanCreationException + @PostConstruct初始化逻辑抛异常修逻辑、加日志、移出启动路径
@Transactional 在 @PostConstruct 失效代理尚未生成/自调用TransactionTemplate/ApplicationRunner
@PreDestroy 未执行prototype/kill -9/未关闭上下文手动关闭、优雅停机
BPP 顺序导致注入异常自定义 BPP 早于 AutowiredAnnotationBPP实现 Ordered/PriorityOrdered
BPP 返回 null后续 BPP 链提前结束返回原 bean 或代理
FactoryBean 产品未销毁容器只管理 FactoryBeanFactoryBean 自己销毁产品
  • 深挖点(面试官常追的 6 个):

    1. 初始化三兄弟为什么是这个顺序:@PostConstruct 由 CommonAnnotationBeanPostProcessor 在 postProcessBeforeInitialization 调用,属于 BPP before;afterPropertiesSet 是 InitializingBean 接口契约,在 invokeInitMethods 中执行;init-method 最后执行。这样注解层可以最先做校验/赋值,接口层做标准初始化,配置层做业务自定义初始化;三者可以叠加,顺序固定。
    2. BPP 的排序与 AOP 代理时机:BPP 在 refresh 第 6 步注册,按 PriorityOrdered → Ordered → 非排序执行;AnnotationAwareAspectJAutoProxyCreator 是 BPP,在 postProcessAfterInitialization 调 wrapIfNecessary 生成代理。普通 AOP 不在 postProcessBeforeInstantiation 做;如果自定义 BPP 在那里返回代理,会跳过常规注入/初始化,只再走 after 阶段。BPP 自身通常不被自动代理,避免递归。
    3. InstantiationAwareBeanPostProcessor 三个方法的边界:postProcessBeforeInstantiation 可返回代理短路创建;postProcessAfterInstantiation 返回 false 可跳过属性填充;postProcessProperties 做属性注入(postProcessPropertyValues 已废弃)。MergedBeanDefinitionPostProcessor 在实例化后、注入前缓存 @Autowired/@PostConstruct 元数据;SmartInstantiationAwareBeanPostProcessor 负责选构造器和 early reference。
    4. 三级缓存与 AOP 早期代理:一级 singletonObjects 放完整 Bean;二级 earlySingletonObjects 放提前暴露的 Bean;三级 singletonFactories 放 ObjectFactory。A 实例化后、注入前把工厂放入三级缓存;B 依赖 A 时通过 getSingleton(allowEarlyReference=true) 触发 getEarlyBeanReference,必要时提前创建 AOP 代理,保证 B 注入到的是代理对象。构造器循环依赖没有 early reference 阶段,默认无解,可用 @Lazy/ObjectProvider 打破。
    5. @Autowired/@Resource/@Value 的处理链:AutowiredAnnotationBeanPostProcessor 在 determineCandidateConstructors 选构造器、postProcessMergedBeanDefinition 缓存注入元数据、postProcessProperties 执行注入;@Resource 由 CommonAnnotationBeanPostProcessor 按名称优先注入;@Value 由 AutowiredAnnotationBeanPostProcessor 通过 Environment/占位符解析。字段注入发生在 populateBean,早于 @PostConstruct,所以 @PostConstruct 里可以读到注入的字段;但自调用事务/异步仍然绕过代理。
    6. 销毁与作用域的边界:容器只管理自己创建的 singleton 的销毁;prototype 的 @PreDestroy/DisposableBean 不会自动调用。销毁顺序是 @PreDestroy → DisposableBean.destroy → destroy-method,依赖者先于被依赖者;ContextClosedEvent 在销毁前发布,监听器还能访问 Bean。@Bean 默认推断 close/shutdown 作为 destroy-method,不想调用要显式 destroyMethod="";kill -9 不会触发任何回调。
  • 追问链:

    1. Bean 生命周期分几个阶段? → 定义、实例化、属性注入、初始化、使用、销毁。
    2. 生命周期从哪开始? → BeanDefinition 解析/注册;不是 new。
    3. BeanDefinition 阶段能扩展吗? → 能,BFPP/RegistryPostProcessor。
    4. 实例化前 BPP 能做什么? → postProcessBeforeInstantiation,可返回代理短路。
    5. 实例化有哪几种方式? → Supplier、工厂方法、构造器。
    6. 构造器怎么选? → determineCandidateConstructors;单构造器隐式,多构造器需 @Autowired。
    7. MergedBeanDefinitionPostProcessor 做什么? → 缓存注入/生命周期元数据。
    8. 属性注入在哪? → populateBean。
    9. postProcessAfterInstantiation 返回 false 会怎样? → 跳过属性填充。
    10. Aware 回调顺序? → BeanName/BeanClassLoader/BeanFactory 先;ApplicationContextAware 等在 BPP before。
    11. @PostConstruct 谁处理? → CommonAnnotationBeanPostProcessor。
    12. @PostConstruct 和 afterPropertiesSet 谁先? → @PostConstruct 先。
    13. afterPropertiesSet 和 init-method 谁先? → afterPropertiesSet 先。
    14. AOP 代理何时创建? → 初始化后,BPP after。
    15. BPP after 能做什么? → 代理、包装、校验、埋点。
    16. 销毁顺序? → @PreDestroy → DisposableBean.destroy → destroy-method。
    17. @PreDestroy 谁处理? → CommonAnnotationBeanPostProcessor(DestructionAware)。
    18. prototype 会执行销毁吗? → 不会,容器不管理。
    19. @Bean 的 destroy-method 怎么来的? → 默认推断 close/shutdown,可显式指定/关闭。
    20. 循环依赖怎么解决? → 三级缓存 + early reference。
    21. getEarlyBeanReference 做什么? → 必要时提前创建 AOP 代理。
    22. 构造器循环依赖能解决吗? → 默认不能;@Lazy/ObjectProvider 打破。
    23. Boot 2.6 之后循环依赖? → 默认禁止,allow-circular-references=false。
    24. BFPP 和 BPP 区别? → 改定义 vs 改实例。
    25. BPP 顺序怎么排? → PriorityOrdered → Ordered → 非排序。
    26. BPP 自己会被代理吗? → 通常不会,避免递归。
    27. BPP 什么时候注册? → refresh 第 6 步,早于普通单例。
    28. BeanPostProcessorChecker 是什么? → 提前创建 Bean 时提示 BPP 未全部注册。
    29. BPP 返回 null 会怎样? → 保留上一个结果并提前结束后续 BPP,不会把 Bean 置空。
    30. @Autowired 谁处理? → AutowiredAnnotationBeanPostProcessor。
    31. @Resource 和 @Autowired 区别? → 名称优先 vs 类型优先;处理器不同。
    32. @Value 谁处理? → AutowiredAnnotationBeanPostProcessor,配合 Environment/占位符。
    33. @PostConstruct 里事务为什么失效? → 代理未生成/自调用绕过。
    34. @PostConstruct 里异步为什么失效? → 同上,@Async 代理未生效。
    35. @PostConstruct 能注入字段吗? → 能,注入在 populateBean 已完成。
    36. FactoryBean 生命周期? → FactoryBean 本身是 Bean;产品由 getObject() 创建。
    37. &name 是什么? → 取 FactoryBean 本身,不是产品。
    38. FactoryBean 产品经过 BPP 吗? → 通常经过 after-initialization BPP;synthetic 定义会跳过。
    39. FactoryBean 产品谁销毁? → 通常 FactoryBean 自己负责。
    40. Spring 有哪些作用域? → singleton/prototype/request/session/application/websocket。
    41. prototype 注入 singleton 会怎样? → 只注入一次;用 ObjectProvider/scoped proxy/@Lookup。
    42. @Lazy 注入是什么? → 注入代理,首次调用才创建目标。
    43. SmartInitializingSingleton 何时? → 所有非懒加载单例之后。
    44. Lifecycle 和 SmartLifecycle 区别? → 后者自动启动、有 phase、回调更完整。
    45. @DependsOn 影响销毁吗? → 影响创建顺序,销毁反向。
    46. ContextClosedEvent 和销毁顺序? → 事件先发,再 Lifecycle 停止,再销毁单例。
    47. 优雅停机怎么做? → shutdown hook、SIGTERM、server.shutdown=graceful、preStop。
    48. Bean 初始化失败怎么排查? → 看 BeanCreationException cause 链、Bean 名、阶段。
    49. 启动慢和生命周期有关吗? → 单例多、@PostConstruct 重、AOP/扫描大、数据源初始化。
    50. Spring 6/AOT 对生命周期有影响吗? → 核心回调仍在;Jakarta 注解、AOT 生成代理/反射提示。
  • 生产案例/取舍(示例,替换成你的项目):

    • @PostConstruct 里做远程调用/全量缓存加载,启动超时;改成 ApplicationRunner 或 SmartLifecycle 异步预热。
    • @PostConstruct 自调用 @Transactional 方法,事务不生效;改用 TransactionTemplate 或拆到另一个 Bean。
    • @PreDestroy 里 flush 缓冲,但发布用 kill -9 丢数据;改优雅停机 + preStop + 超时。
    • prototype Bean 的 @PreDestroy 没执行,连接泄漏;改 ObjectProvider 手动关闭或池化。
    • 自定义 BPP 返回 null,后续 BPP 链被截断;改为返回原 bean/代理。
    • 自定义 BPP 顺序太早,@Autowired 字段还是 null;实现 Ordered 调整到 AutowiredAnnotationBPP 之后。
    • @Bean 的 close() 被自动推断为 destroy-method,关闭了共享资源;显式 destroyMethod=""。
    • AOP + 循环依赖,B 注入到早期代理;确认 getEarlyBeanReference 生效,避免重复代理。
    • FactoryBean 产品是连接池,容器关闭没销毁;FactoryBean 实现 DisposableBean 关闭产品。
    • @Scope("prototype") 注入 singleton,只拿到一个实例;改 scoped proxy/ObjectProvider。
    • Boot 2.6 升级后循环依赖启动失败;重构依赖或临时 allow-circular-references=true。
    • @Lazy Bean 的 @PostConstruct 首次访问才执行;启动预热要显式 getBean。
    • SmartLifecycle 启动失败导致应用启动失败;phase 排序、异常处理、健康检查。
    • 取舍:字段注入换简洁,代价是循环依赖/不可变性;构造器注入换不可变/显式依赖,代价是循环依赖更难;@PostConstruct 换启动即初始化,代价是启动阻塞;prototype 换隔离,代价是销毁管理;@Lazy 换启动速度,代价是首请求延迟。
  • 易错点:

    • 认为 Bean 生命周期从 new 开始。
    • 认为 BeanDefinition 阶段会创建实例。
    • 认为 @PostConstruct 在属性注入之前。
    • 认为 @PostConstruct 在 AOP 代理之后。
    • 认为 @PostConstruct 里自调用事务/异步一定生效。
    • 认为 afterPropertiesSet 先于 @PostConstruct。
    • 认为 init-method 先于 afterPropertiesSet。
    • 认为 @PreDestroy 一定执行。
    • 认为 prototype 由容器销毁。
    • 认为 @Bean 不会推断 destroy-method。
    • 认为 BPP 能修改 BeanDefinition。
    • 认为 BFPP 能代理 Bean。
    • 认为 BPP 对所有 Bean 都生效。
    • 认为 BPP 顺序无所谓。
    • 认为 BPP 返回 null 会把 Bean 置空(实际保留上一个结果并提前结束链)。
    • 认为 postProcessBeforeInstantiation 返回代理后还会走完整生命周期。
    • 认为 postProcessAfterInitialization 返回 null 会清空 Bean。
    • 认为 @Autowired 静态字段生效。
    • 认为 @Resource 和 @Autowired 完全一样。
    • 认为构造器循环依赖靠三级缓存。
    • 认为 getEarlyBeanReference 只返回原始对象。
    • 认为 FactoryBean 的产品由容器按普通单例销毁。
    • 认为 @Lazy 只影响注入不影响生命周期。
    • 认为 SmartLifecycle 和 Lifecycle 一样。
    • 认为 @DependsOn 只影响创建不影响销毁。
    • 认为 Boot 2.6 仍默认允许循环依赖。
    • 认为 @PostConstruct 方法可以带参数/返回值。
    • 认为 BPP 自身会被 AOP 代理。
    • 认为 @PreDestroy 在 DisposableBean.destroy 之后。
    • 认为 ApplicationContextAware 一定早于 BeanNameAware。
  • 30 秒口述稿:

Bean 生命周期是定义、实例化、属性注入、初始化、使用、销毁。定义阶段 BFPP 改 BeanDefinition;实例化前 postProcessBeforeInstantiation 可短路;实例化后 MergedBeanDefinitionPostProcessor 缓存元数据;populateBean 做 @Autowired/@Resource/@Value 注入;初始化先 Aware,再 BPP before 的 @PostConstruct,然后 afterPropertiesSet、init-method,最后 BPP after 生成 AOP 代理。销毁顺序是 @PreDestroy、DisposableBean.destroy、destroy-method。循环依赖靠三级缓存和 getEarlyBeanReference;prototype 和 kill -9 不执行销毁。

  • 3 分钟展开顺序:结论(六阶段 + BFPP/BPP 两条线)→ 定义/实例化前/实例化 → 属性注入与注入注解 → Aware/@PostConstruct/afterPropertiesSet/init-method → AOP 代理与 BPP 顺序 → 三级缓存/循环依赖 → 销毁/作用域/FactoryBean → 生产坑与排查。