三级缓存为什么是三级?二级缓存不够吗

0 阅读8分钟

★

推荐阅读人群 :Java 后端、准备面试的同学、被 BeanCurrentlyInCreationException 炸过的人

一句话导读 :三级缓存不是为了存三个对象,是为了把"要不要提前生成 AOP 代理"这个决定,拖到最后一刻。


01 · 升级之后,项目起不来了

一个跑了半年的老项目,把 Spring Boot 从 2.5 升到 3.x,启动直接挂:

The dependencies of some beans
form a cycle:

  orderService
   ↑        ↓
  notifyService

代码一行没动。原因是 Spring Boot 从 2.6 起把 spring.main.allow-circular-references 的默认值从 true 改成了 false。以前悄悄给你解开的环,现在直接拒绝启动。

这件事的讽刺之处在于:大部分人知道"Spring 能解决循环依赖",但说不清"怎么解决的",更说不清"为什么它自己又默认关掉了"。这篇把这三个问题一次讲清。

先把场景定死。所谓循环依赖,就是两个 Bean 互相要对方:

@Service
public class A {
    @Autowired B b;
}
@Service
public class B {
    @Autowired A a;
}

如果 Spring 跟人一样死板——"A 造完才能给 B,B 造完才能给 A"——这里就该死锁。它没有死锁,靠的是三级缓存提前把"半个 A"交出去。

02 · 三个缓存,各存什么

三个 Map 都在 DefaultSingletonBeanRegistry 里,属于 Spring Framework,不是 Spring Boot:

// 一级:成品,初始化走完能直接对外用
private final Map<String, Object> singletonObjects =
    new ConcurrentHashMap<>(256);

// 二级:早期引用,new 出来了属性还没填
private final Map<String, Object> earlySingletonObjects =
    new HashMap<>(16);

// 三级:工厂,调用它才拿到早期引用
private final Map<String, ObjectFactory<?>>
    singletonFactories = new HashMap<>(16);

一句话记住三者:一级放成品,二级放半成品,三级放"怎么造半成品"的图纸。

三级缓存不是随便加的,它和 Bean 的生命周期严丝合缝:

  • 三级 —— Bean 刚 new 出来,还没填属性。Spring 往三级塞一个工厂 () -> getEarlyBeanReference(beanName, mbd, bean)
  • 二级 —— 有人来要这个 Bean 的早期引用,工厂被调用一次,结果 upgrade 到二级,工厂本身从三级删掉
  • 一级 —— 属性填完、初始化走完,成品进一级,二级清空

03 · A→B→A,一步步走通

把上一节的代码跑一遍,关键在"谁在什么时候去查缓存":

new A()        -> 三级登记 A 的工厂
A 填属性,要 B
  new B()      -> 三级登记 B 的工厂
  B 填属性,要 A
    getSingleton("a")
      1 一级? 无
      2 二级? 无
      3 三级? 有 -> getObject()
                    -> 拿到 A 的早期引用
                    -> 放进二级,删掉三级
    B 拿到 A,填完属性,初始化 -> 进一级
A 拿到 B,填完属性,初始化   -> 进一级

第 8 行就是环被打破的地方:B 没有傻等 A 造完,而是从三级拿到了一个"还没填属性、但已经有身份的 A"。整张流程图放在下面,对着看更清楚:

![三级缓存 A→B→A 完整流程](Spring 循环依赖怎么破?三级缓存少一级都不行-插图-三级缓存流程.png)

查缓存的源码是这个顺序,一级→二级→三级:

protected Object getSingleton(String name,
        boolean allowEarlyRef) {
    // 查一级:成品
    Object bean = singletonObjects.get(name);
    boolean creating =
        isSingletonCurrentlyInCreation(name);
    if (bean == null && creating) {
        synchronized (singletonObjects) {
            // 查二级:早期引用
            bean = earlySingletonObjects.get(name);
            if (bean == null && allowEarlyRef) {
                // 查三级:调工厂
                ObjectFactory<?> f =
                    singletonFactories.get(name);
                if (f != null) {
                    bean = f.getObject();
                    earlySingletonObjects
                        .put(name, bean);
                    singletonFactories.remove(name);
                }
            }
        }
    }
    return bean;
}

注意那个 isSingletonCurrentlyInCreation(name) 判断。它保证只有"正在创建中的 Bean"才会往下查——一个已经造好的 Bean 不会被二级缓存里的旧引用顶替。

04 · 为什么非要三级,二级不行吗

这是整篇最值钱的问题。很多人背答案"三级缓存解决循环依赖",但追一句"两级不够吗"就卡住。

先看两级缓存为什么会翻车。假设只有一级 + 二级,实例化 A 之后直接把裸对象丢进二级。B 拿到的是原始对象。但 A 如果带 @Transactional,正常流程会在初始化阶段被 AnnotationAwareAspectJAutoProxyCreator 包成代理对象。结果就是:

  • B 手里那个是裸 A,事务增强全丢
  • 容器一级缓存里那个是代理 A
  • 同一个 Bean 出现了两个引用,而且是不同对象

那"实例化后立刻生成代理,再放二级"行不行?也不行,代价太大:

  • 90% 以上的 Bean 根本没有循环依赖,却要为它们全部提前跑一遍代理判断
  • 很多增强依赖属性填充的结果,实例刚 new 出来就代理,拿到的可能是个"半吊子"

两级缓存的死结是:二级只能放对象,而"放裸对象还是代理对象"这个决定,在实例化那一刻还做不出来。

三级缓存的解法是放工厂,而不是放对象。工厂的触发条件是"真有人来要早期引用":

  • A 没有被任何人提前引用 —— 工厂永远不调用,A 走正常流程,在初始化阶段按需生成代理
  • A 被 B 提前引用了 —— 工厂在这一刻调用 getEarlyBeanReference(),当场判断要不要代理,生成后放进二级
  • 后面 C 也来要 A —— 直接从二级拿那个已经生成的引用,不会再触发工厂,保证单例唯一

用一句话概括:三级缓存把"要不要提前代理"的选择权,从 Bean 创建时,推迟到了有人真正向它要引用的那一刻。

还有一个防重复代理的细节。AbstractAutoProxyCreator 里有个 earlyProxyReferences 集合,专门记录哪些 Bean 已经被提前代理过。等 A 走到初始化末尾的 postProcessAfterInitialization,后置处理器一看"这个 Bean 已经代理过了",就不再代理第二次,直接返回原始对象;随后 Spring 发现二级缓存里有那个提前生成的代理,就把它取出来放进一级。

整条链路保证了 B 手里那个代理 A,和容器里最终的 A,是同一个对象。这才是三级缓存真正解决的问题,不是"能解开环"那么简单——解开环只是副产品。

05 · 哪些环 Spring 解不开

三级缓存不是万能的,四种情况它救不了:

  • 构造器注入的环 —— public A(B b) 这种。Bean 连实例都还没 new 出来,没东西可以提前暴露,直接 BeanCurrentlyInCreationException
  • prototype 作用域的环 —— Spring 不缓存原型 Bean,每次都重新造,三级缓存对它是空的
  • 被 @Async 之类包装的 Bean —— 部分场景下会绕开常规代理路径,导致早期引用和最终引用不一致
  • 默认配置下的 Spring Boot 2.6+ —— 解决得了,但它选择不解决,直接拒绝启动

第三条最阴。它不会启动时报错,而是运行到某个调用链时,注入的对象少了一层异步增强,表现出来就是"方法怎么同步执行了"。

顺带说个面试常考点:构造器注入解不开环,反而是件好事——让循环依赖在启动阶段就暴露,而不是藏到运行时某个调用链里炸。所以我一直建议能用构造器注入就用构造器注入。

06 · 工程里怎么处理

真遇到了,我的顺序是这样的:

  • 优先拆环 —— 把互相引用的逻辑抽到第三个 Service,或者改成事件驱动。循环依赖大多意味着职责边界没划清,缓存只是把它藏起来
  • 临时解围用 @Lazy —— 在其中一个注入点加 @Lazy,Spring 会先塞一个代理进去,等真正用到时才去取目标 Bean。构造器注入的环也能这么绕
  • 别随手改开关 —— 把 allow-circular-references 改回 true 能让它启动,但那是把设计问题又埋回去。真要开,写清楚为什么开、谁负责拆

@Lazy 也不是免费的:那个代理会一直挂在字段上,第一次调用才触发真实 Bean 的创建,时序跟普通注入不一样,调试时容易懵。它是创可贴,不是手术。

07 · 三句话总结

  1. 三级缓存不是三个对象,是成品 / 半成品 / 造半成品的工厂,核心动作是提前暴露一个"有身份但还没填属性"的引用,把环打断
  2. 之所以要三级,是因为二级只能放对象,而"放裸对象还是 AOP 代理"这个决定必须延迟到有人真正来要引用的那一刻才能做
  3. 构造器注入的环解不开、prototype 的环解不开,Spring Boot 2.6+ 默认干脆全拒绝——能解开不代表该用,@Lazy 是创可贴,拆环才是手术

往期同类推荐

  • 《Spring Boot 4.x + JDK 25 都有了,还在守着 JDK 8?》 —— 同是 Spring 生态的版本坑,升级前先看这篇
  • 《线程池先排队还是先扩线程?一道题筛掉一半人》 —— 另一道高频源码题,一起啃

写在最后

觉得有用的话,拜托两件事:

  • 点「赞」+「推荐」(在看)
  • 关注「斯维赤」 —— Java 实战、源码拆解、踩坑复盘,持续更新

我们下期再见