Spring循环依赖全解

Spring 循环依赖与三级缓存

一、什么是循环依赖

1.1 定义

循环依赖是指两个及两个以上的 Bean 互相持有对方引用，形成闭环依赖关系。

典型场景：A 依赖 B、B 依赖 A；或多 Bean 闭环：A→B→C→A。

1.2 产生问题

Spring 单例 Bean 创建核心流程：先实例化原始对象 → 再填充属性依赖。

在互相依赖场景下会形成递归死循环：

创建 A 需要先注入 B → 创建 B 需要先注入 A → 无限递归，最终抛出创建异常。

1.3 核心适配规则（高频）

Spring 三级缓存仅能解决：单例 Bean + Setter/字段注入（@Autowired）的循环依赖

无法解决、直接抛出 BeanCurrentlyInCreationException 的场景：

• 构造方法注入（实例化阶段执行，还未创建三级缓存）
• 多例（Prototype）Bean（不进入任何缓存）
• 部分工厂方法、@Lookup 动态依赖场景

二、单例 Bean 完整标准生命周期（三级缓存原理基础）

Spring 单例 Bean 正常创建全流程，也是循环依赖解决的核心时序依据：

2.1 完整执行步骤

• 实例化 createBeanInstance：通过构造方法 new 出原始裸对象，仅分配内存，所有属性为空。
• 提前暴露半成品 Bean（核心）：实例化完成、属性填充之前，执行 addSingletonFactory，将包装了早期代理逻辑的 ObjectFactory 放入三级缓存。
  • 存入工厂时不会主动创建代理，实现代理懒加载
  • 仅在发生循环依赖时，才会触发工厂执行代理生成
• 属性填充 populateBean：解析 @Autowired、Setter 方法，注入所依赖的 Bean。
• 初始化 initializeBean（固定执行顺序）：
  • 初始化前置后置处理器：postProcessBeforeInitialization
  • 自定义初始化方法：@PostConstruct → InitializingBean#afterPropertiesSet → 自定义 init-method
  • 初始化后置后置处理器：postProcessAfterInitialization（常规 AOP 代理默认创建入口）
• 存入一级缓存：将完全初始化、可对外使用的成品 Bean 放入一级缓存，同时清空二、三级缓存对应记录。

2.2 AOP 代理创建时机关键区别

• 无循环依赖：代理在 postProcessAfterInitialization 中统一创建
• 有循环依赖：代理提前通过三级缓存工厂创建，后置处理器不再重复生成

三、三级缓存结构、作用与互斥规则

三级缓存均位于 DefaultSingletonBeanRegistry 核心类中，三者互斥存在，同一个 BeanName 不会同时存在多级缓存中。

3.1 一级缓存：singletonObjects

• 存储内容：完全初始化完毕的成品 Bean
• 状态：已完成实例化、属性填充、初始化、代理创建
• 作用：全局唯一对外提供可用的单例 Bean，用户最终获取的 Bean 均来自一级缓存

3.2 二级缓存：earlySingletonObjects

• 存储内容：提前暴露的半成品 Bean（原始裸对象 / 提前生成的早期 AOP 代理）
• 状态：未完成属性填充、未完成初始化
• 作用：缓存已经通过三级工厂生成的早期对象，避免重复调用 ObjectFactory.getObject() 重复创建代理，提升性能

3.3 三级缓存：singletonFactories

• 存储内容：Bean 的工厂对象 ObjectFactory
• 核心逻辑：工厂持有原始裸 Bean，内部封装 getEarlyBeanReference 早期代理创建逻辑
• 执行时机：无循环依赖时，工厂永久不执行；仅发生循环依赖，其他 Bean 需要提前获取当前 Bean 时，才调用 getObject()
• 核心价值：实现代理懒加载，解决 AOP 场景下循环依赖产生多代理对象的问题

3.4 缓存更替规则（核心）

• Bean 实例化后，存入三级缓存，此时一、二级缓存无数据
• 触发循环依赖时，三级工厂生成对象/代理，存入二级缓存，删除三级缓存记录
• Bean 完全初始化完成后，存入一级缓存，删除二、三级缓存记录

3.5 循环依赖判断依据

Spring 维护集合 singletonsCurrentlyInCreation，存储正在创建中的 BeanName。

属性填充时，若发现依赖的 Bean 在该集合中，判定为循环依赖，触发三级缓存解析逻辑。

四、无 AOP 代理场景：三级缓存解决循环依赖流程

图源：rocky-fang - Spring循环依赖文章

4.1 场景

单例 Bean A、B 互相字段/Setter 注入，无 AOP 代理。

4.2 完整执行流程

• 创建 A：实例化原始 A 对象，存入三级缓存工厂；属性填充阶段发现依赖 B，转而创建 B。
• 创建 B：实例化原始 B 对象，存入三级缓存工厂；属性填充阶段发现依赖 A。
• 容器检测到 A 处于创建中，从 A 的三级缓存取出 ObjectFactory，执行 getObject()，无代理逻辑，直接返回原始 A 半成品对象。
• 将原始 A 存入二级缓存，删除 A 的三级缓存工厂，完成 A 注入 B 的操作。
• B 完成全部属性填充、初始化流程，存入一级缓存，成为成品 Bean。
• 回到 A 的创建流程，注入完整的成品 B，A 走完初始化流程，最终存入一级缓存，循环依赖解决。

五、带 AOP 代理场景：三级缓存核心价值（重点）

当 Bean 需要 AOP 代理（事务、切面等），必须依赖三级缓存，仅靠二级缓存会产生严重问题。

5.1 核心 AOP 组件与方法

自动代理核心类：AnnotationAwareAspectJAutoProxyCreator

• getEarlyBeanReference()：仅三级缓存工厂触发
  • 向 earlyProxyReferences 存入标记，记录当前 Bean 已提前生成早期代理
  • 调用 wrapIfNecessary() 生成代理对象并返回
• postProcessAfterInitialization()：常规代理创建入口
  • 读取 earlyProxyReferences 标记，若已提前创建代理，直接返回，避免重复生成

5.2 带 AOP 完整循环依赖流程

• 实例化原始 A，将封装代理逻辑的 ObjectFactory 存入三级缓存，此时不生成代理。
• A 属性填充需要 B，启动 B 的创建流程。
• 实例化原始 B，存入三级缓存工厂；B 属性填充需要 A。
• 容器检测 A 正在创建，取出 A 的三级缓存工厂，执行 getObject()，触发 getEarlyBeanReference。
• 打上已代理标记，通过 wrapIfNecessary 生成早期代理对象 proxyA。
• proxyA 存入二级缓存，删除 A 的三级缓存工厂，将 proxyA 注入 B。
• B 完成所有创建流程，存入一级缓存。
• 回到 A，注入完整成品 B，执行初始化流程。
• 执行后置处理器时，检测到 A 已有代理标记，不再重复创建代理。
• 最终将二级缓存中唯一的 proxyA 存入一级缓存，全局代理对象唯一。

5.3 为什么不能只用二级缓存？（核心原理）

假设舍弃三级缓存，实例化 Bean 后直接生成代理放入二级缓存：

• 手动调用 wrapIfNecessary 生成代理，绕开 getEarlyBeanReference，不会添加代理标记。
• B 注入该代理对象，完成依赖填充，B 存入一级缓存。
• A 继续执行初始化后置处理，检测无代理标记，再次生成一个全新的代理对象。
• 最终结果：B 持有的代理、一级缓存中的代理是两个不同对象。

5.4 多代理对象导致的线上问题

• @Transactional 事务失效
• 切面逻辑重复执行/不执行
• 并发锁、本地缓存数据不一致
• 对象引用不统一引发各种诡异 Bug

六、终极总结（背诵版）

• 循环依赖解决范围：仅单例 + Setter/字段注入可解，构造注入、多例 Bean 直接报错。
• 三级缓存分工：一级存成品、二级存早期半成品、三级存代理工厂（懒加载）。
• 二级缓存作用：优化性能，避免循环依赖时重复执行工厂方法创建代理。
• 三级缓存核心意义：延迟代理创建、打上全局标记，保证整个容器中 Bean 代理对象唯一。
• 核心设计思想：无循环依赖则不提前创建代理，兼顾性能与循环依赖场景的兼容性。

到此这篇关于Spring循环依赖的文章就介绍到这了,更多相关Spring循环依赖内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论