当前位置：首页 > news >正文

【Spring源码08】终极万字拆解：三级缓存如何完美解决Bean循环依赖（面试压轴必刷）

news 2026/6/2 16:30:39

🔥Spring源码全套连载系列（持续更新）

上一篇我们彻底吃透了Bean完整生命周期，明确了一个核心关键节点：

Bean在实例化阶段，就会提前曝光半成品对象，为解决循环依赖做铺垫。

今天我们攻克Spring源码最难、最绕、面试压轴必考的终极难点：Bean循环依赖与三级缓存原理。

90%的程序员只会背：一级存成品、二级存半成品、三级存工厂。

但一问深层原理就彻底懵：

循环依赖到底发生在Bean生命周期的哪一步？
为什么一定要三级缓存？两级缓存能不能解决问题？
三级缓存存的ObjectFactory工厂到底有什么用？
为什么构造方法循环依赖无法解决？
AOP代理后的Bean，循环依赖是如何保证对象一致性的？

本篇摒弃废话、纯源码落地，逐行拆解三级缓存执行流程，彻底终结循环依赖所有疑问，看完直接吊打99%面试者！

一、前置认知：什么是Spring循环依赖？

1.1 定义与场景

循环依赖：两个或多个Bean之间互相依赖对方，形成闭环依赖关系。

日常开发最常见的场景：属性注入循环依赖

@Service public class AService { @Autowired private BService bService; } @Service public class BService { @Autowired private AService aService; }

A依赖B，B又依赖A，形成闭环，这就是经典循环依赖。

1.2 三种循环依赖类型（重点）

Spring循环依赖分三种，只有一种能解决、一种无解、一种部分解决：

1. 属性注入循环依赖（setter/@Autowired）：完全解决（三级缓存核心场景）
2. 构造方法循环依赖：完全无法解决（面试高频）
3. 多例Bean循环依赖：无法解决

本篇核心拆解：单例Bean属性注入循环依赖的底层解决方案。

1.3 核心疑问：为什么会出现循环依赖报错？

结合Bean生命周期理解：

正常Bean流程：实例化 -> 属性填充 -> 初始化 -> 存入单例池

如果没有三级缓存：

创建A，实例化完成，属性填充阶段需要B
B未创建，开始创建B，B实例化完成，属性填充需要A
此时A还未完成创建、未存入单例池，容器找不到A
循环等待，最终抛出BeanCurrentlyInCreationException循环依赖异常

核心矛盾：半成品Bean无法被提前获取，导致互相依赖卡死。

二、Spring三级缓存核心结构（源码级）

Spring解决循环依赖的核心，就是DefaultSingletonBeanRegistry中的三个Map缓存，各司其职、层层兜底。

先熟记三级缓存源码定义，这是所有原理的基础：

// 一级缓存：存放【完全初始化完成、可直接使用】的单例Bean private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(); // 二级缓存：存放【实例化完成、未属性填充、未初始化】的半成品Bean（原始Bean/代理Bean） private final Map<String, Object> earlySingletonObjects = new HashMap<>(); // 三级缓存：存放【Bean工厂对象ObjectFactory】，用于提前生成Bean引用、创建代理 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();

2.1 三级缓存逐一级详解（必背）

① 一级缓存 singletonObjects

作用：存储完全成熟、初始化完毕、可直接对外使用的单例Bean。

时机：Bean完成初始化、AOP代理增强后，最终存入。

特点：全局唯一成品Bean，项目运行全程复用。

② 二级缓存 earlySingletonObjects

作用：存储半成品Bean（实例化完成，未完成属性填充和初始化）。

时机：从三级缓存获取Bean后，升级存入二级缓存，避免重复创建。

核心价值：解决多Bean互相依赖同一个半成品Bean的重复创建问题。

③ 三级缓存 singletonFactories

重中之重、最难理解的一级

存储内容：不是Bean对象，是ObjectFactory<?> 匿名工厂对象。

核心作用：提前曝光Bean引用，支持提前生成AOP代理对象。

这也是为什么不能只用两级缓存，必须要有三级缓存的核心原因！

三、完整循环依赖执行流程（逐步骤还原）

以AService、BService互相依赖为例，全程还原三级缓存执行链路，无任何跳跃步骤。

前置规则：Spring容器默认单例、非懒加载、允许循环依赖。

步骤1：容器创建AService

根据BeanDefinition，通过反射实例化A原生空对象（此时属性全为空）
标记A为正在创建中（inCreation）
核心操作：将A的ObjectFactory工厂存入三级缓存 singletonFactories
进入A的属性填充阶段，发现需要依赖BService

步骤2：容器创建BService

容器未找到B，开始实例化B原生空对象
标记B为正在创建中，B的工厂存入三级缓存
进入B的属性填充阶段，发现需要依赖AService

步骤3：B尝试获取A，触发三级缓存查询

容器获取Bean的查询顺序是固定优先级：一级 → 二级 → 三级

查一级缓存：A未创建完成，无数据
查二级缓存：A未升级，无数据
查三级缓存：找到A的ObjectFactory工厂
执行工厂getObject()方法，获取A的引用（如需AOP则提前创建代理）
缓存升级：将A半成品存入二级缓存，同时删除三级缓存中的A工厂

步骤4：B完成创建

B成功获取到A的半成品对象，完成属性填充
B执行初始化、后置处理、AOP代理
B完全创建完成，存入一级缓存

步骤5：A完成剩余创建流程

A成功获取到完整的B对象，完成属性填充
A执行初始化、后置处理、AOP代理
A创建完成，从二级缓存取出，存入一级缓存
清空二、三级缓存中A的临时数据

至此，循环依赖完美解决，无异常、对象完全一致。

四、终极灵魂拷问：为什么两级缓存不行？

这是面试最高频、最难答的压轴题，90%开发者答不到核心点！

4.1 假设只有一级+二级缓存

二级缓存只能存储固定的半成品Bean对象。

如果Bean需要AOP动态代理，会出现致命问题：

二级缓存提前曝光的是原生裸对象
最终存入一级缓存的是代理对象
出现两个不同的Bean对象：依赖注入的是原生对象，容器最终使用的是代理对象
导致事务、AOP切面失效，程序严重bug！

4.2 三级缓存的不可替代性

三级缓存存储的是ObjectFactory工厂，具备动态执行能力：

当其他Bean依赖当前Bean时：

工厂实时判断当前Bean是否需要AOP代理
需要代理则提前生成代理对象进行曝光
不需要代理则直接曝光原生对象
保证：提前曝光的对象 = 最终存入单例池的对象

终极结论：

两级缓存只能解决普通Bean循环依赖，无法解决AOP代理Bean的循环依赖；三级缓存是为了保证代理对象一致性而生！

五、为什么构造方法循环依赖无法解决？

很多人死记硬背：构造循环依赖无解。今天从源码层面彻底讲透！

5.1 三级缓存的存入时机

三级缓存工厂的存入时机：Bean实例化完成之后、属性填充之前。

核心源码位置：doCreateBean()方法中addSingletonFactory()。

5.2 构造注入的执行逻辑

构造方法注入：必须先传参依赖，才能完成实例化。

执行顺序：

创建A，需要通过构造方法注入B
还未完成A的实例化，无法进入三级缓存存入阶段
创建B，构造方法需要注入A
A未实例化、无三级缓存、无任何曝光渠道
彻底卡死，直接抛出循环依赖异常

一句话总结：构造注入先依赖、后实例化；三级缓存需要先实例化、后曝光，时机完全冲突，因此无解！

六、多例Bean为什么无法解决循环依赖？

因为Spring不缓存多例Bean：

多例Bean每次获取都会新建对象，不存入一、二、三级缓存
无法提前曝光半成品对象
互相依赖时无限创建新对象，最终栈溢出报错

七、三级缓存执行优先级&缓存流转机制

7.1 Bean获取优先级（固定）

一级缓存（成品） > 二级缓存（半成品） > 三级缓存（工厂）

7.2 完整缓存流转链路

三级缓存 → 执行工厂getObject() → 升级存入二级缓存 → Bean创建完成 → 升级存入一级缓存 → 清空临时缓存

缓存设计精髓：三级是工具、二级是过渡、一级是最终归宿。

八、面试满分题库（本篇压轴必背）

1、Spring三级缓存分别是什么？作用是什么？

一级缓存singletonObjects存储完全初始化完成的成品单例Bean；二级缓存earlySingletonObjects存储实例化完成、未初始化的半成品Bean，避免重复创建；三级缓存singletonFactories存储Bean工厂对象，用于提前曝光Bean引用，支持AOP代理Bean的循环依赖，保证对象一致性。