Appearance
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。分层要点:
- 定义阶段不是“Bean 生命周期”但决定后面一切:
BeanDefinition保存 class、scope、lazy、depends-on、构造参数、属性、init/destroy 方法、factory-method 等;BeanFactoryPostProcessor/BeanDefinitionRegistryPostProcessor在这一阶段修改或注册定义。ConfigurationClassPostProcessor解析@Configuration/@ComponentScan/@Bean也在这里(3.1-1 第 5 步)。 - 实例化前可以短路:
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation可以返回一个代理/对象,直接跳过常规实例化、属性注入和初始化;Spring 之后仍会执行postProcessAfterInitialization。AOP 的常规代理不在这里做,而是在初始化后。 - 实例化与属性注入:
createBeanInstance走 Supplier、工厂方法或构造器(determineCandidateConstructors选构造器);MergedBeanDefinitionPostProcessor在实例化后缓存注入元数据;populateBean先postProcessAfterInstantiation(返回 false 可跳过属性填充),再postProcessProperties完成@Autowired/@Resource/@Value注入,最后应用属性值。 - 初始化阶段:
invokeAwareMethods先回调BeanNameAware、BeanClassLoaderAware、BeanFactoryAware;ApplicationContextAwareProcessor等 BPP 再回调EnvironmentAware、ResourceLoaderAware、ApplicationContextAware等;随后 BPP before 执行@PostConstruct,invokeInitMethods执行afterPropertiesSet和自定义init-method,最后 BPP after 生成 AOP 代理。 - 使用阶段:非懒加载单例在
finishBeanFactoryInitialization的preInstantiateSingletons中创建;所有单例完成后回调SmartInitializingSingleton.afterSingletonsInstantiated;FactoryBean的getObject()产品通常也会经过 BPP after(synthetic 定义除外);prototype 每次getBean新建,容器不缓存。 - 销毁阶段:容器关闭时发布
ContextClosedEvent,LifecycleProcessor.onClose停止SmartLifecycle,再销毁单例;顺序是DestructionAwareBeanPostProcessor(@PreDestroy)→DisposableBean.destroy→ 自定义destroy-method,依赖者先于被依赖者销毁。prototype 的销毁不由容器管理,kill -9也不会执行销毁回调。 - 扩展点坐标:定义阶段
BFPP/RegistryPostProcessor;实例化前InstantiationAwareBPP.postProcessBeforeInstantiation;属性注入postProcessAfterInstantiation/postProcessProperties;初始化前后BeanPostProcessor;销毁DestructionAwareBeanPostProcessor;另有MergedBeanDefinitionPostProcessor、SmartInstantiationAwareBeanPostProcessor、Aware、InitializingBean/DisposableBean、@PostConstruct/@PreDestroy、init-method/destroy-method、FactoryBean、SmartInitializingSingleton、SmartLifecycle。 - 常见失效与排查:
@PostConstruct自调用@Transactional/@Async不生效(代理还没生成或自调用绕过代理);@PreDestroy在 prototype/kill -9下不执行;自定义 BPP 顺序错会让注入/代理异常;BPP 返回 null 会提前结束后续 BPP 链;@Bean会推断close/shutdown作为 destroy-method;Boot 2.6+ 默认禁止循环依赖。
- 定义阶段不是“Bean 生命周期”但决定后面一切:
图/流程:
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-methodtext
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-methodtext
作用域:
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。
- Spring Framework 5.3.x / 6.x:
生命周期阶段与扩展点:
| 阶段 | 关键动作 | 扩展点 | 备注 |
|---|---|---|---|
| 定义 | 解析/注册/合并 BeanDefinition | BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor | 不创建实例 |
| 实例化前 | resolveBeforeInstantiation | InstantiationAwareBPP.postProcessBeforeInstantiation | 返回非 null 可短路 |
| 实例化 | 构造器/工厂/Supplier | SmartInstantiationAwareBPP.determineCandidateConstructors | 构造器循环依赖在此暴露 |
| 合并定义 | 缓存注入/生命周期元数据 | MergedBeanDefinitionPostProcessor | 实例化后、注入前 |
| early reference | 暴露三级缓存工厂 | SmartInstantiationAwareBPP.getEarlyBeanReference | 解决 setter 循环依赖 |
| 属性注入 | populateBean | InstantiationAwareBPP.postProcessAfterInstantiation/postProcessProperties | @Autowired/@Resource/@Value |
| Aware | 回调容器能力 | Aware + ApplicationContextAwareProcessor | 3 个在 invokeAwareMethods |
| 初始化前 | BPP before | BeanPostProcessor.postProcessBeforeInitialization | @PostConstruct 在这里 |
| 初始化 | afterPropertiesSet、init-method | InitializingBean、@Bean(initMethod) | 顺序固定 |
| 初始化后 | BPP after | BeanPostProcessor.postProcessAfterInitialization | AOP 代理在这里 |
| 使用 | 单例池/原型新建 | SmartInitializingSingleton | 所有单例后回调 |
| 销毁 | 关闭容器 | DestructionAwareBeanPostProcessor、DisposableBean、destroy-method | 依赖者先销毁 |
- 初始化/销毁顺序:
| 顺序 | 初始化 | 销毁 |
|---|---|---|
| 1 | @PostConstruct(BPP before) | @PreDestroy(DestructionAwareBPP) |
| 2 | InitializingBean.afterPropertiesSet() | DisposableBean.destroy() |
| 3 | 自定义 init-method | 自定义 destroy-method |
记忆:注解 → 接口 → 配置;初始化从小到大,销毁同样从注解到配置。
- 扩展点全景:
| 扩展点 | 作用阶段 | 典型用途 | 注意 |
|---|---|---|---|
BeanFactoryPostProcessor | 定义 | 改 BeanDefinition、占位符 | 不能代理 Bean |
BeanDefinitionRegistryPostProcessor | 定义 | 扫描/注册 BeanDefinition | BFPP 子类型,最先执行 |
InstantiationAwareBeanPostProcessor | 实例化/注入 | 短路创建、属性注入 | 三个方法各有边界 |
SmartInstantiationAwareBeanPostProcessor | 实例化/循环依赖 | 选构造器、early reference | AOP 早期代理 |
MergedBeanDefinitionPostProcessor | 实例化后 | 缓存注入元数据 | @Autowired 元数据 |
BeanPostProcessor | 初始化前后 | 代理、校验、埋点 | 顺序敏感 |
DestructionAwareBeanPostProcessor | 销毁前 | @PreDestroy | 只对容器管理的 Bean |
Aware | 初始化前 | 拿容器/环境/资源 | 能用构造器注入就别用 |
InitializingBean/DisposableBean | 初始化/销毁 | 资源打开/关闭 | 与注解/配置可叠加 |
FactoryBean | 使用 | 创建复杂对象 | 产品生命周期特殊 |
SmartInitializingSingleton | 所有单例后 | 缓存预热、校验 | 只非懒加载单例 |
SmartLifecycle | 容器刷新/关闭 | 启停后台线程 | 有 phase/autoStartup |
- 注入注解对比:
| 注解 | 处理器 | 解析规则 | 备注 |
|---|---|---|---|
@Autowired | AutowiredAnnotationBeanPostProcessor | 先类型,再 @Qualifier/名称 | 可构造器/字段/方法;required=false |
@Qualifier | 同上 | 缩小候选 | 与 @Autowired 配合 |
@Value | 同上 | 占位符/SpEL | 依赖 Environment/占位符解析 |
@Resource | CommonAnnotationBeanPostProcessor | 先名称,再类型 | JSR-250;Boot 3 用 jakarta.annotation |
@Inject | AutowiredAnnotationBeanPostProcessor | JSR-330,按类型 | 需对应 API |
@PostConstruct | CommonAnnotationBeanPostProcessor | 初始化前 | 必须无参、返回 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 产品未销毁 | 容器只管理 FactoryBean | FactoryBean 自己销毁产品 |
深挖点(面试官常追的 6 个):
- 初始化三兄弟为什么是这个顺序:
@PostConstruct由CommonAnnotationBeanPostProcessor在postProcessBeforeInitialization调用,属于 BPP before;afterPropertiesSet是InitializingBean接口契约,在invokeInitMethods中执行;init-method最后执行。这样注解层可以最先做校验/赋值,接口层做标准初始化,配置层做业务自定义初始化;三者可以叠加,顺序固定。 - BPP 的排序与 AOP 代理时机:BPP 在 refresh 第 6 步注册,按
PriorityOrdered→Ordered→ 非排序执行;AnnotationAwareAspectJAutoProxyCreator是 BPP,在postProcessAfterInitialization调wrapIfNecessary生成代理。普通 AOP 不在postProcessBeforeInstantiation做;如果自定义 BPP 在那里返回代理,会跳过常规注入/初始化,只再走 after 阶段。BPP 自身通常不被自动代理,避免递归。 InstantiationAwareBeanPostProcessor三个方法的边界:postProcessBeforeInstantiation可返回代理短路创建;postProcessAfterInstantiation返回 false 可跳过属性填充;postProcessProperties做属性注入(postProcessPropertyValues已废弃)。MergedBeanDefinitionPostProcessor在实例化后、注入前缓存@Autowired/@PostConstruct元数据;SmartInstantiationAwareBeanPostProcessor负责选构造器和 early reference。- 三级缓存与 AOP 早期代理:一级
singletonObjects放完整 Bean;二级earlySingletonObjects放提前暴露的 Bean;三级singletonFactories放ObjectFactory。A 实例化后、注入前把工厂放入三级缓存;B 依赖 A 时通过getSingleton(allowEarlyReference=true)触发getEarlyBeanReference,必要时提前创建 AOP 代理,保证 B 注入到的是代理对象。构造器循环依赖没有 early reference 阶段,默认无解,可用@Lazy/ObjectProvider打破。 @Autowired/@Resource/@Value的处理链:AutowiredAnnotationBeanPostProcessor在determineCandidateConstructors选构造器、postProcessMergedBeanDefinition缓存注入元数据、postProcessProperties执行注入;@Resource由CommonAnnotationBeanPostProcessor按名称优先注入;@Value由AutowiredAnnotationBeanPostProcessor通过Environment/占位符解析。字段注入发生在populateBean,早于@PostConstruct,所以@PostConstruct里可以读到注入的字段;但自调用事务/异步仍然绕过代理。- 销毁与作用域的边界:容器只管理自己创建的 singleton 的销毁;prototype 的
@PreDestroy/DisposableBean不会自动调用。销毁顺序是@PreDestroy→DisposableBean.destroy→destroy-method,依赖者先于被依赖者;ContextClosedEvent在销毁前发布,监听器还能访问 Bean。@Bean默认推断close/shutdown作为 destroy-method,不想调用要显式destroyMethod="";kill -9不会触发任何回调。
- 初始化三兄弟为什么是这个顺序:
追问链:
- Bean 生命周期分几个阶段? → 定义、实例化、属性注入、初始化、使用、销毁。
- 生命周期从哪开始? → BeanDefinition 解析/注册;不是
new。 - BeanDefinition 阶段能扩展吗? → 能,BFPP/RegistryPostProcessor。
- 实例化前 BPP 能做什么? →
postProcessBeforeInstantiation,可返回代理短路。 - 实例化有哪几种方式? → Supplier、工厂方法、构造器。
- 构造器怎么选? →
determineCandidateConstructors;单构造器隐式,多构造器需@Autowired。 - MergedBeanDefinitionPostProcessor 做什么? → 缓存注入/生命周期元数据。
- 属性注入在哪? →
populateBean。 postProcessAfterInstantiation返回 false 会怎样? → 跳过属性填充。- Aware 回调顺序? → BeanName/BeanClassLoader/BeanFactory 先;ApplicationContextAware 等在 BPP before。
@PostConstruct谁处理? →CommonAnnotationBeanPostProcessor。@PostConstruct和afterPropertiesSet谁先? →@PostConstruct先。afterPropertiesSet和 init-method 谁先? →afterPropertiesSet先。- AOP 代理何时创建? → 初始化后,BPP after。
- BPP after 能做什么? → 代理、包装、校验、埋点。
- 销毁顺序? →
@PreDestroy→DisposableBean.destroy→ destroy-method。 @PreDestroy谁处理? →CommonAnnotationBeanPostProcessor(DestructionAware)。- prototype 会执行销毁吗? → 不会,容器不管理。
@Bean的 destroy-method 怎么来的? → 默认推断close/shutdown,可显式指定/关闭。- 循环依赖怎么解决? → 三级缓存 + early reference。
getEarlyBeanReference做什么? → 必要时提前创建 AOP 代理。- 构造器循环依赖能解决吗? → 默认不能;
@Lazy/ObjectProvider打破。 - Boot 2.6 之后循环依赖? → 默认禁止,
allow-circular-references=false。 - BFPP 和 BPP 区别? → 改定义 vs 改实例。
- BPP 顺序怎么排? → PriorityOrdered → Ordered → 非排序。
- BPP 自己会被代理吗? → 通常不会,避免递归。
- BPP 什么时候注册? → refresh 第 6 步,早于普通单例。
- BeanPostProcessorChecker 是什么? → 提前创建 Bean 时提示 BPP 未全部注册。
- BPP 返回 null 会怎样? → 保留上一个结果并提前结束后续 BPP,不会把 Bean 置空。
@Autowired谁处理? →AutowiredAnnotationBeanPostProcessor。@Resource和@Autowired区别? → 名称优先 vs 类型优先;处理器不同。@Value谁处理? →AutowiredAnnotationBeanPostProcessor,配合 Environment/占位符。@PostConstruct里事务为什么失效? → 代理未生成/自调用绕过。@PostConstruct里异步为什么失效? → 同上,@Async代理未生效。@PostConstruct能注入字段吗? → 能,注入在 populateBean 已完成。- FactoryBean 生命周期? → FactoryBean 本身是 Bean;产品由
getObject()创建。 &name是什么? → 取 FactoryBean 本身,不是产品。- FactoryBean 产品经过 BPP 吗? → 通常经过 after-initialization BPP;synthetic 定义会跳过。
- FactoryBean 产品谁销毁? → 通常 FactoryBean 自己负责。
- Spring 有哪些作用域? → singleton/prototype/request/session/application/websocket。
- prototype 注入 singleton 会怎样? → 只注入一次;用
ObjectProvider/scoped proxy/@Lookup。 @Lazy注入是什么? → 注入代理,首次调用才创建目标。- SmartInitializingSingleton 何时? → 所有非懒加载单例之后。
- Lifecycle 和 SmartLifecycle 区别? → 后者自动启动、有 phase、回调更完整。
@DependsOn影响销毁吗? → 影响创建顺序,销毁反向。- ContextClosedEvent 和销毁顺序? → 事件先发,再 Lifecycle 停止,再销毁单例。
- 优雅停机怎么做? → shutdown hook、SIGTERM、
server.shutdown=graceful、preStop。 - Bean 初始化失败怎么排查? → 看
BeanCreationExceptioncause 链、Bean 名、阶段。 - 启动慢和生命周期有关吗? → 单例多、
@PostConstruct重、AOP/扫描大、数据源初始化。 - 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。 @LazyBean 的@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。
- 认为 Bean 生命周期从
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 → 生产坑与排查。