知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 34 - Spring 循环依赖怎么解决 > 导读:本文从一个启动报错 `BeanCurrentlyInCreationException` 出发,讲清 Spring 三级缓存解决循环依赖的完整流程、为什么"三级"不能省成"两级"、哪些场景解决不了,以及从设计上根治循环依赖的思路。适合排查 Spring 启动问题、以及准备后端面试的同学。 ## 一、先建立全局认知 ### Q:启动时报 BeanCurrentlyInCreationException,这个错误说明了什么? A:先看报错原文: ```text BeanCurrentlyInCreationException: Error creating bean 'serviceA': Requested bean is currently in creation: Is there an unresolvable circular reference? ``` 这条错误的关键词是 `currently in creation`——Spring 在创建 `serviceA` 的过程中,又需要 `serviceA`,而它还没创建完。这类"A 依赖 B、B 又依赖 A"的依赖闭环就叫**循环依赖**(circular dependency)。 看到这个报错,要区分两种情况:一种是 Spring 本来能解决的(setter/字段注入的循环依赖),另一种是 Spring 也解决不了的(构造器注入等)。下面分别展开。 ### Q:什么是循环依赖? A:一句话定义:两个(或多个)Bean 互相持有对方,形成依赖闭环,谁都无法先被完整创建出来。最典型的是 ServiceA 与 ServiceB 互相注入: ```text ServiceA → 依赖 ServiceB → 依赖 ServiceA(循环了) ``` ```java @Service public class ServiceA { @Autowired private ServiceB serviceB; } @Service public class ServiceB { @Autowired private ServiceA serviceA; } ``` ## 二、理解核心机制 ### Q:Spring 用什么机制解决 setter/字段注入的循环依赖? A:用**三级缓存**。这是理解整个问题的核心。三级缓存定义在 `DefaultSingletonBeanRegistry` 中,按"成熟度"分三层: ```java // Spring 用三级缓存解决循环依赖(DefaultSingletonBeanRegistry) // 一级缓存:存放完全初始化好的 Bean(成品) Map<String, Object> singletonObjects; // 二级缓存:存放早期暴露的 Bean(半成品,属性还没注入) Map<String, Object> earlySingletonObjects; // 三级缓存:存放 Bean 工厂(ObjectFactory,用于创建早期引用) Map<String, ObjectFactory<?>> singletonFactories; ``` 用一句话概括三层的分工:一级缓存放"成品",二级缓存放"半成品",三级缓存放"能造出半成品的工厂"。之所以需要"工厂"而不是直接放对象,是为了把"是否要生成 AOP 代理"这个决策**延迟**到真正被循环引用时才做——这一点是后面"为什么需要三级"的关键。 ### Q:以 A → B → A 为例,Spring 的完整解决流程是怎样的? A:关键在于:Spring 允许"先把还没注入属性的 A 的早期引用借给 B",等 B 建好后 A 再补全属性。完整步骤如下: ```text 1. 创建 A: - 实例化 A(new ServiceA(),此时属性为空) - 将 A 的 ObjectFactory 放入三级缓存 - 开始注入 A 的属性 → 发现需要 B 2. 创建 B: - 实例化 B(new ServiceB()) - 将 B 的 ObjectFactory 放入三级缓存 - 开始注入 B 的属性 → 发现需要 A 3. 获取 A(解决循环): - 一级缓存没有 A(还没创建完) - 二级缓存没有 A - 三级缓存有 A 的 ObjectFactory → 调用 getObject() 获取 A 的早期引用 - 将 A 的早期引用放入二级缓存,删除三级缓存 - 返回 A 的早期引用给 B 4. B 创建完成: - B 拿到 A 的早期引用,属性注入完成 - B 初始化完成,放入一级缓存 5. A 创建完成: - A 拿到 B(从一级缓存),属性注入完成 - A 初始化完成,放入一级缓存 ``` ### Q:`getSingleton` 的源码逻辑是怎样的? A:整个"逐级查找"的判定逻辑可以简化为下面这段(真实源码包含锁与更多边界判断,这里只保留主干): ```java // 简化版源码逻辑 protected Object getSingleton(String beanName) { // 1. 先查一级缓存 Object bean = singletonObjects.get(beanName); if (bean == null && isSingletonCurrentlyInCreation(beanName)) { // 2. 再查二级缓存 bean = earlySingletonObjects.get(beanName); if (bean == null) { // 3. 最后查三级缓存 ObjectFactory<?> factory = singletonFactories.get(beanName); if (factory != null) { bean = factory.getObject(); // 获取早期引用 earlySingletonObjects.put(beanName, bean); // 升级到二级缓存 singletonFactories.remove(beanName); // 删除三级缓存 } } } return bean; } ``` 注意查找顺序和"升级"动作:先一级(成品)、再二级(半成品)、最后三级(工厂);一旦从三级缓存拿到早期引用,就把它**升级**到二级缓存并删除三级缓存。这样同一个 Bean 的早期引用只会被创建一次,后续再有人来取,直接命中二级缓存。  *图:A、B 相互依赖时,早期引用在三级缓存之间升降级、最终落入一级缓存的过程。* [编辑 Excalidraw 源图](/images/java-interview-copy/concurrent/34-spring-circular-dep-spring-circular-dep-three-level-cache-diagram.excalidraw) ### Q:为什么需要三级缓存,两级不行吗? A:这是这道题最能区分"背过"和"懂了"的一问。核心在于**三级缓存的 ObjectFactory 可以返回代理对象**:  *图:三级缓存为什么要延迟创建代理对象* ```text 关键:三级缓存的 ObjectFactory 可以返回代理对象 如果 A 有 AOP 代理(如 @Transactional),注入给 B 的必须是代理对象,不是原始对象。 三级缓存的 ObjectFactory.getObject(): - 如果 A 需要代理 → 返回代理对象 - 如果 A 不需要代理 → 返回原始对象 如果只用两级缓存: - 创建 A 时就要决定是否生成代理 - 但此时 A 还没初始化完,提前创建代理违反了 Spring 的设计原则 (正常流程是:实例化 → 属性注入 → 初始化 → AOP 代理) 三级缓存的意义:延迟代理对象的创建,只有在被循环依赖引用时才提前创建代理。 ``` 换句话说,第二级缓存存的是"某个早期引用",而第三级缓存存的是"如何产生这个早期引用"的方法。多出这一层的价值不是多存数据,而是把"要不要生成代理、生成什么代理"的判断推迟到最后一刻,避免为所有 Bean 无差别地提前做代理。这是典型的"延迟计算"设计取舍:用一点额外的查找复杂度,换取不破坏 Spring 原有的 Bean 生命周期约定。 ## 三、放进真实场景 ### Q:哪些情况下循环依赖解决不了?分别怎么绕? A:三级缓存有一个前提——**对象已经实例化(`new` 过了),只是属性还没注入**。凡是打破这个前提的场景,Spring 都无能为力。 **情况一:构造器注入。** 因为构造器注入时 A 连 `new` 都没执行,根本没东西可以放进缓存: ```java // 构造器注入 → 无法解决循环依赖 @Service public class ServiceA { private final ServiceB serviceB; public ServiceA(ServiceB serviceB) { // 构造器注入 this.serviceB = serviceB; } } // 原因:构造器注入时,A 还没实例化(new 都没执行),无法放入缓存 // 三级缓存的前提是:对象已经实例化(new 了),只是属性还没注入 ``` 绕行方案有两条——改成字段注入,或用 `@Lazy` 打断依赖的即时获取: ```java // 解决方案一:改用 @Autowired 字段注入 @Service public class ServiceA { @Autowired private ServiceB serviceB; } // 解决方案二:用 @Lazy 延迟加载 @Service public class ServiceA { private final ServiceB serviceB; public ServiceA(@Lazy ServiceB serviceB) { // 注入的是 ServiceB 的代理对象,实际使用时才创建真正的 ServiceB this.serviceB = serviceB; } } ``` `@Lazy` 之所以有效,是因为它注入的是一个**代理**,构造 A 时并不会真的去创建 B,依赖的"即时获取"被推迟到了真正调用 B 的方法时。 **情况二:prototype 作用域。** prototype Bean 不走三级缓存(每次都创建新实例),因此无法复用"早期引用"这套机制: ```java // prototype Bean 不走三级缓存(每次都创建新实例) @Scope("prototype") @Service public class ServiceA { @Autowired private ServiceB serviceB; } // 如果 A 和 B 都是 prototype 且互相依赖 → 报错 ``` **情况三:@Async 导致的循环依赖。** `@Async` 会生成代理对象,可能导致早期引用和最终对象不一致: ```java // @Async 会生成代理对象,可能导致早期引用和最终对象不一致 @Service public class ServiceA { @Autowired private ServiceB serviceB; @Async public void asyncMethod() { ... } } // 解决:在 ServiceA 上加 @Lazy,或调整依赖关系 ``` 这三种情况的共同点是:**依赖在"实例化阶段"就已经需要对方存在**,而不是等到"属性注入阶段"。理解这条主线,就能自行判断一个新场景能否被三级缓存救回来。 ### Q:Spring Boot 2.6+ 有什么变化? A:从 Spring Boot 2.6 开始**默认禁止循环依赖**,存在循环依赖时启动直接报错。这是官方推动"从设计上消除循环依赖"的一个强信号。如果确实要临时放开: ```yaml # Spring Boot 2.6 开始默认禁止循环依赖 # 如果存在循环依赖,启动直接报错 # 临时允许(不推荐,应该从设计上消除循环依赖) spring: main: allow-circular-references: true ``` 这里要强调"临时"二字:这个开关只是让应用先跑起来,并没有消除依赖闭环本身。它更像是给老项目升级时留的缓冲垫,而不是长期方案。 ### Q:如何从设计上避免循环依赖? A:绕开报错的技巧(字段注入、`@Lazy`)只是治标,真正的解法是消除依赖闭环。常用四种手段: 1. 提取公共逻辑到第三个服务(A → C ← B); 2. 用事件驱动解耦(A 发事件,B 监听); 3. 用接口隔离,依赖抽象而非具体实现; 4. 审视职责划分是否合理,合并或拆分服务。 其中第 1、2 条最常用:提取公共服务是从依赖结构上把"互相依赖"变成"共同依赖";事件驱动则是把"同步调用"换成"异步通知",从时序上彻底断开闭环。判断用哪种,取决于两个 Bean 的交互是否真的需要同步返回结果——需要就是结构问题(提取公共依赖),不需要就是时序问题(改事件)。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:按四点作答: 1. Spring 用三级缓存解决 setter/字段注入的循环依赖:一级存成品、二级存半成品、三级存 ObjectFactory。 2. 三级缓存的核心作用:延迟 AOP 代理对象的创建,只在被循环引用时才提前生成代理。 3. 构造器注入无法解决:因为对象还没实例化,无法放入缓存。用 `@Lazy` 可以绕过。 4. 最佳实践:从设计上避免循环依赖(提取公共服务、用事件驱动解耦)。 ### Q:Spring 创建 Bean 的完整流程是什么? A:实例化(反射调用构造器)→ 放入三级缓存 → 属性注入(@Autowired)→ Aware 接口回调 → BeanPostProcessor 前置处理 → `InitializingBean.afterPropertiesSet` / `@PostConstruct` → BeanPostProcessor 后置处理(AOP 代理在这里生成)→ 放入一级缓存。 把这条流程和三级缓存对照着看,就能理解"循环依赖能解决"的本质:三级缓存插入的位置正好在"实例化之后、属性注入之前",所以 Spring 才有一个"半成品"可以借出去。 --- ## 自测 1. 一级、二级、三级缓存分别存什么?为什么 `getSingleton` 查到三级缓存后要把结果升级到二级缓存? 2. 只用两级缓存为什么不行?三级缓存里的 ObjectFactory 到底解决了什么问题? 3. 为什么构造器注入的循环依赖无法用三级缓存解决?`@Lazy` 又是如何绕过的? 4. Spring Boot 2.6+ 默认禁止循环依赖,`allow-circular-references: true` 为什么只能算临时方案?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入