「Spring 怎么解决循环依赖」是字节美团的高频题,答案三缓存几乎人人会背;追问「为什么是三级不是二级」,一半人卡住。这篇从生命周期讲起,把追问链一次焊死。
实例化(反射造空对象) → 填属性(@Autowired注入) → Aware回调
→ 前置处理 → 初始化 → 后置处理 → 就绪使用 → 销毁
细节版十步:实例化 → 属性赋值 → BeanNameAware/BeanFactoryAware → postProcessBeforeInitialization(@PostConstruct 在这执行)→ afterPropertiesSet → init-method → postProcessAfterInitialization(AOP 代理在这诞生)→ 使用 → @PreDestroy/destroy → destroy-method。
自己跑一遍比背十遍强:
@Component
public class OrderService implements InitializingBean {
@Autowired
private UserService userService; // 第2步:属性注入
@PostConstruct
public void post() { System.out.println("5. PostConstruct"); }
@Override
public void afterPropertiesSet() { System.out.println("6. afterPropertiesSet"); }
@PreDestroy
public void pre() { System.out.println("9. PreDestroy"); }
}
控制台顺序即答案。记住关键锚点:依赖注入在初始化之前,AOP 代理在初始化之后——三级缓存的故事全建立在这两个时序上。
十步里 BeanPostProcessor 出现两次(前置/后置),是 Spring 留给扩展者的主舞台:@Autowired 的注入器、AOP 的代理器、@PostConstruct 的触发器,全站在这个舞台上干活。自定义初始化还有第三条路:@Bean(initMethod = "xxx")——三种回调选一个够用,别三个全写再去背顺序。
两组最容易混的顺序再钉一钉:@PostConstruct 在 afterPropertiesSet 之前——注解回调先于接口回调;Aware 在前置处理之前——先让 Bean 认识环境,再让处理器加工。把这两组说死,追问「代理和 init-method 谁先谁后」就不会含糊:代理诞生在后置处理,排在所有初始化完成之后。
A 依赖 B,B 依赖 A。创建 A 时发现要 B,创建 B 时发现要 A——不处理就是无限递归。
Spring 的解法是把「创建」拆成「实例化」和「初始化」两截:A 实例化后虽然还没注入属性,但引用已经存在,先把这个半成品挂个号,B 要 A 时把引用给它。三块缓存各司其职:
A↔B 完整走一遍:
① 实例化A → A的工厂放进三级缓存
② A填属性,发现要B → 转去创建B
③ 实例化B → B的工厂进三级缓存
④ B填属性,发现要A → 逐级找:
一级没有 / 二级没有 / 三级找到工厂
→ 调工厂拿到A的早期引用,升级放二级
⑤ B拿着A的引用完成初始化 → B进一级缓存
⑥ 回到A继续:注入B、初始化 → A进一级缓存
对着源码看更扎实:三块缓存就是 DefaultSingletonBeanRegistry 里的三个 Map 字段;doCreateBean 里一行 addSingletonFactory(beanName, () -> getEarlyBeanReference(...)) 把工厂放进三级;getSingleton 的查找路径一级→二级→三级逐级下探,命中三级后「调工厂、放二级、删三级」三连一气呵成。面试报得出这三个方法名,可信度立刻不同。
只用两级行不行?不需要 AOP 时行;需要 AOP 时出 bug。
问题出在代理对象的生成时机:正常流程里,代理在初始化后(后置处理)才创建。若 A 需要代理且只用两级缓存:B 从二级缓存拿到的是 A 的原始对象;A 初始化完后容器里放的是代理对象——B 怀里的 A 和容器里的 A 不是同一个,切面对 B 手里的 A 完全失效。
三级的 ObjectFactory 是「延迟决策」:平时不提前造代理;真遇到循环依赖,B 来取引用时才调用工厂,提前生成代理给它,并保证后续容器里用的也是这同一个代理——一个 Bean 只会被代理一次,且全局一致。
再补一刀边界:Spring 从不承诺所有循环依赖都能解。它承诺的只有「setter/字段注入的单例循环」这一种。凡是需要更早介入的增强场景,三级缓存同样接不住。面试里把这个适用范围说出口,比背出三块缓存的名字更见功底。
@Lazy(注入一个代理,首次调用才真创建)spring.main.allow-circular-references=false)——官方态度:循环依赖是设计坏味道,能开闸但别开@Lazy 的戏法值得拆开看:它注入的根本不是目标对象,而是一个代理。首次方法调用打到代理上,代理才触发真正的创建,之后每次调用转发给真身。构造器循环因此解开——两边各拿一张「空头支票」,谁也不用在构造期等到谁。代价是首次调用的延迟,和排查时的迷惑性:注入对象的类名带着代理后缀,和真实类型对不上号。
@Component
public class A {
private final B b;
public A(@Lazy B b) { this.b = b; } // 注入的是B的代理
// 首次调用b的方法,才触发B的完整创建
}
还有个同源的隐蔽坑:单例 Bean 里注入 prototype。单例只创建一次,注入只发生一次——里面的 prototype 字段从此定型,之后每次用它都是同一个实例。以为每次拿新的?并没有。解法是注入 ObjectProvider,用的时候再取;或用 @Lookup 方法注入。根子和循环依赖同一条:注入的时机只有一次,生命周期错位就出幻觉。
工程上的正解不是开开关,是消除循环:抽出公共逻辑下沉、改用事件机制解耦(13.4)。
生命周期是「实例化与初始化两截」,三级缓存利用这个缝隙用半成品引用打破死循环——第三级的存在只为让 AOP 代理在循环依赖里也只生成一次。