三级缓存存的不是对象,是"晚一点再决定暴露什么"
引言
面试被问到"Spring 怎么解决循环依赖",多数人能背出"三级缓存"四个字,然后卡住。再追问一句"为什么必须是三级,两级行不行",基本就沉默了。
这个问题背后有个很容易被忽略的事实:三级缓存里存的根本不是一个 Bean,而是一个工厂。它要解决的不是"存哪儿",而是"什么时候决定暴露原始对象还是代理对象"。
[配图:A 创建到一半需要 B,B 回头需要 A,请求落进 singletonFactories 拿到早期引用]
顺便说一个和它直接相关的线上事故:Spring Boot 2.5 升 2.6,服务启动直接失败,日志里画了一个环:
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
| aService defined in file [...]
↑ ↓
| bService defined in file [...]
└─────┘
Action: Relying upon circular references is discouraged and they are prohibited by default.
2.6 把 allow-circular-references 默认改成了 false。这不是"框架变严格了",而是官方终于承认:循环依赖多数时候是设计问题,三级缓存只是让老代码别在启动时炸掉的兜底。
这篇按源码顺序讲透:先看循环依赖卡在哪一步,再拆 doGetBean 的三次查询,然后是三级缓存每一级的职责,最后说清哪些场景它根本救不了。
一、现象:卡在"实例化"和"属性填充"之间
Bean 的创建分两步,这两步的位置决定了循环依赖能不能被解决:
第一步 createBeanInstance,调构造器,对象从无到有。
第二步 populateBean,给字段和 setter 注入依赖。
如果依赖是通过构造器传进来的,第一步就要求 B 已经存在,而此时 A 连对象都还没有,没有任何东西可以提前暴露——直接抛 BeanCurrentlyInCreationException。
如果依赖是 setter 或字段注入,第二步才需要 B,这时 A 的实例已经在内存里了,只是字段还没填。这个"半成品"就是三级缓存能玩出花来的全部空间。
所以第一个结论要先立住:三级缓存解决的是 setter / 字段注入的循环依赖,构造器注入它一点忙都帮不上。 面试里能把这句话说出来,基本就能区分"背过"和"读过源码"。
二、入口:doGetBean 的三次"有没有"
循环依赖的整个流程,起点是 AbstractBeanFactory#doGetBean:
protected <T> T doGetBean(String name, ...) {
Object sharedInstance = getSingleton(beanName); // ① 先问缓存
if (sharedInstance != null) {
return (T) getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// ② 缓存没有,进入创建流程
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
return createBean(beanName, mbd, args); // ③ 真正创建
});
}
return (T) getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
关键在 getSingleton(beanName, ObjectFactory) 这个重载,它做了三件事:beforeSingletonCreation 把当前 beanName 塞进 singletonsCurrentlyInCreation,调用工厂创建,afterSingletonCreation 把它移除并放进一级缓存。
而 singletonsCurrentlyInCreation 就是循环检测的依据:当 B 在创建过程中再次请求 A,发现 A 已经在这个集合里,就知道"这次请求发生在 A 的创建过程中",也就是循环依赖,于是转去三级缓存找早期引用。如果找不到,就直接抛异常。
三、三级缓存,每一级各管什么
| 缓存 | 存的内容 | 放入时机 | 移除时机 |
|---|---|---|---|
singletonObjects(一级) | 完整可用的 Bean | 创建 + 初始化全部完成 | 容器销毁 |
earlySingletonObjects(二级) | 早期引用,可能是代理 | 首次通过工厂取到早期引用时 | 成品放入一级时 |
singletonFactories(三级) | ObjectFactory 工厂,不是对象 | 实例化完成、属性填充之前 | 被取用一次后,或成品放入一级时 |
3.1 一级缓存:只有成品能进
singletonObjects 是 ConcurrentHashMap<String, Object>,存的是"构造、注入、初始化、后置处理全跑完"的 Bean。它不参与循环依赖的解决,它只是最终归宿。
3.2 二级缓存:保证"只生成一次早期引用"
earlySingletonObjects 存的是提前暴露出来的引用。为什么要单独一级?因为工厂每次调 getObject() 都可能生成新的代理对象——如果三个 Bean 都依赖 A,各自调一次工厂,就会拿到三个不同的代理,容器里到底用哪个就乱了。二级缓存把"第一次的产物"钉住。
3.3 三级缓存:为什么存工厂,不存对象
singletonFactories 存的是 ObjectFactory,在 doCreateBean 里注册,位置很关键:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args); // ① 实例化
Object bean = instanceWrapper.getWrappedInstance();
// ② 属性填充之前,先暴露"半成品"的工厂
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
populateBean(beanName, mbd, instanceWrapper); // ③ 注入依赖(可能触发循环)
Object exposedObject = initializeBean(beanName, bean, mbd); // ④ 初始化 + AOP 代理
return exposedObject;
}
addSingletonFactory 必须早于 populateBean:晚一步,B 在注入时就找不到 A 的半成品,循环依赖直接失败。
而工厂里包的 getEarlyBeanReference,会走一遍 SmartInstantiationAwareBeanPostProcessor,让 AOP 有机会在这里就把代理造出来。
3.4 取用的那一刻:getSingleton 的三级查询
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName); // 一级
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName); // 二级
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName); // 双重检查
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); // 三级
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName); // 用完即焚
}
}
}
}
}
}
return singletonObject;
}
三个细节值得记:查询前先判断 isSingletonCurrentlyInCreation,不在创建中的 Bean 根本不该有早期引用;工厂被取用后立刻从三级移到二级,保证只执行一次;整个补偿逻辑在 synchronized (singletonObjects) 里,因为两个线程并发触发循环依赖时只能有一个造出早期引用。
四、为什么两级不够:AOP 是那个"不能提前"的东西
假设只有两级——实例化完直接把对象放进二级缓存。会发生什么?
A 上有 @Transactional,容器最终暴露给外界的是代理对象。但 B 在循环依赖时从二级缓存拿到的是原始对象,字段里注入的就是原始对象。结果:容器里是代理,B 手里是原始对象,B 调用 A 时事务不生效。这类 Bug 极难排查,因为代码看起来完全正常。
三级缓存的工厂把"暴露什么"推迟到了真正发生循环的时候:没发生循环,工厂根本不会被调用,一切按正常流程走(初始化阶段造代理);发生了循环,工厂被调用的那一刻才决定造早期代理。
还有个配套细节:AbstractAutoProxyCreator 里有个 earlyProxyReferences,记录"这个 Bean 已经提前代理过了"。等到 initializeBean 的 postProcessAfterInitialization 阶段,它发现已经代理过,就直接返回原对象,避免二次代理。少这一笔,同一个 Bean 会被包两层代理,事务、缓存注解的行为都会变得莫名其妙。
[配图:三级缓存的状态流转,实例化 → 工厂入三级 → 循环触发 → 取到早期引用入二级 → 初始化完成入一级并清空前两级]
五、救不了的场景,和版本变化
5.1 构造器注入、prototype、@Async
构造器注入的循环依赖无解,原因第一章说过:对象还没造出来,没有半成品可暴露。报错是 BeanCurrentlyInCreationException: Requested bean is currently in creation,很多人会误以为是线程问题。
解法只有两个:改成 setter/字段注入(不推荐,只是绕过),或者在其中一个依赖上加 @Lazy——注入的是个延迟解析的代理,真正调用时才去容器里取,绕开了启动期的死锁。
@Service
public class AService {
public AService(@Lazy BService b) { } // 注入代理,启动期不解析 B
}
prototype 作用域的 Bean 也不走这套缓存逻辑;@Async 方法如果和循环依赖叠在一起,早期引用拿到的是原始对象,异步代理可能失效,这类组合建议直接用构造器 + @Lazy 规避。
5.2 Spring Boot 2.6 之后默认禁止
从 2.6 起 spring.main.allow-circular-references 默认 false,画环的那段启动失败就是它抛的。要恢复旧行为可以显式打开,但我建议只在迁移期临时开:
spring:
main:
allow-circular-references: true
能启动不等于没问题。 循环依赖意味着两个 Bean 的职责边界没划清,三级缓存只是让它们在启动期勉强拼起来;运行期的初始化顺序、@PostConstruct 的时序、代理是否生效,任何一个环节都可能出问题。
5.3 避坑清单
- 三级缓存救不了构造器注入,只对 setter / 字段注入有效。
addSingletonFactory必须在populateBean之前,顺序错了循环依赖直接失败。- 工厂取用后立刻移到二级缓存,否则多次调用会生成多个代理。
- 早期引用可能导致 AOP 代理提前创建,
earlyProxyReferences防的是二次代理。 - Spring Boot 2.6+ 默认禁止循环依赖,打开开关是临时手段,不是解决方案。
收尾
三级缓存的本质是"延迟决策":先暴露一个工厂,等真的出现循环时,再决定交出去的是原始对象还是代理——两级缓存做不到这一点,因为它没有"等一等"的余地。
你们项目里现在还有循环依赖吗?是拆了接口,还是靠 @Lazy 撑着的?
关注我,每周拆一个真实生产故障。
标题:三级缓存存的不是对象,是"晚一点再决定暴露什么"
作者:jiangyi
地址:http://jiangyi.space/articles/2026/11/05/1793799250602.html
公众号:服务端技术精选
评论