一、循环依赖概览1.1 什么是循环依赖循环依赖是指两个或多个 Bean 之间互相持有对方引用形成闭环。例如 A 依赖 BB 又依赖 A。A 依赖 BB 依赖 A1.2 循环依赖的三种类型// 类型1构造器注入的循环依赖无法解决 Component public class ServiceA { private final ServiceB serviceB; Autowired public ServiceA(ServiceB serviceB) { this.serviceB serviceB; } } // 类型2Setter/字段注入的循环依赖可以解决 Component public class ServiceA { Autowired private ServiceB serviceB; } // 类型3多 Bean 间接循环 A - B - C - A1.3 Spring 能解决哪些循环依赖注入方式单例 Bean原型 BeanSetter / 字段注入✅ 可以解决❌ 无法解决构造器注入❌ 无法解决❌ 无法解决核心结论Spring 只能解决单例 Setter/字段注入的循环依赖其他情况都会报BeanCurrentlyInCreationException。二、三级缓存原理2.1 三级缓存是什么三级缓存定义在DefaultSingletonBeanRegistry中本质是三个 Map// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry /** 一级缓存完整的单例 BeankeybeanName, value完全初始化后的 Bean */ private final MapString, Object singletonObjects new ConcurrentHashMap(256); /** 二级缓存早期暴露的 Bean已实例化但未完全初始化 */ private final MapString, Object earlySingletonObjects new ConcurrentHashMap(16); /** 三级缓存Bean 工厂用于生成早期引用可能包含 AOP 代理 */ private final MapString, ObjectFactory? singletonFactories new HashMap(16);2.2 三个缓存各自的作用缓存名称存放内容作用一级缓存singletonObjects完整的 Bean实例化 属性注入 初始化完成日常 getBean 获取的就是它二级缓存earlySingletonObjects早期的 Bean已实例化属性可能未填充完保存从三级缓存创建的早期引用避免重复创建代理三级缓存singletonFactoriesObjectFactoryBean 工厂 lambda延迟生成早期引用需要时才调用 getObject()保证 AOP 代理只创建一次2.3 三个缓存的生命周期Bean 开始创建实例化完成调用构造器存入三级缓存singletonFactories其他 Bean 引用本 Bean从三级缓存获取调用 ObjectFactory.getObject存入二级缓存earlySingletonObjects从三级缓存移除本 Bean 属性填充 初始化完成存入一级缓存singletonObjects从二级缓存移除核心要点三级缓存的 ObjectFactory 是在实例化之后、属性填充之前存入的。这意味着此时的 Bean 只是一个空壳调用了构造器但依赖还没注入但它的引用已经可以被其他 Bean 拿到了。三、Setter 注入解决全流程3.1 经典场景A → B → AComponent public class A { Autowired private B b; } Component public class B { Autowired private A a; }3.2 完整流程图ClientSpring 容器一级缓存二级缓存三级缓存getBean(a)检查一级缓存null标记 A 正在创建实例化 Anew A将 A 的 ObjectFactory 存入三级缓存属性填充发现需要 BgetBean(b)检查一级缓存null标记 B 正在创建实例化 Bnew B将 B 的 ObjectFactory 存入三级缓存属性填充发现需要 AgetBean(a) 第二次检查一级缓存null检查 A 是否正在创建是检查二级缓存null检查三级缓存找到 A 的 ObjectFactory调用 getObject() 获取 A 的早期引用将 A 的早期引用存入二级缓存从三级缓存移除 A返回 A 的早期引用给 BB 属性填充完成B 初始化完成将 B 存入一级缓存从二级缓存移除 BB 创建完成注入到 AA 属性填充完成A 初始化完成将 A 存入一级缓存从二级缓存移除 A返回 AClientSpring 容器一级缓存二级缓存三级缓存3.3 关键源码getSingleton() — 三级缓存查找// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 1. 从一级缓存获取完整 Bean Object singletonObject this.singletonObjects.get(beanName); // 2. 一级缓存没有 且 当前 Bean 正在创建中 if (singletonObject null isSingletonCurrentlyInCreation(beanName)) { // 3. 从二级缓存获取早期 Bean singletonObject this.earlySingletonObjects.get(beanName); // 4. 二级缓存也没有 且 允许早期引用 if (singletonObject null allowEarlyReference) { synchronized (this.singletonObjects) { // 5. 双重检查锁 singletonObject this.singletonObjects.get(beanName); if (singletonObject null) { singletonObject this.earlySingletonObjects.get(beanName); if (singletonObject null) { // 6. 从三级缓存获取工厂 ObjectFactory? singletonFactory this.singletonFactories.get(beanName); if (singletonFactory ! null) { // 7. 调用工厂创建早期引用核心 singletonObject singletonFactory.getObject(); // 8. 升级到二级缓存 this.earlySingletonObjects.put(beanName, singletonObject); // 9. 从三级缓存移除 this.singletonFactories.remove(beanName); } } } } } } return singletonObject; }注意三级缓存中的ObjectFactory.getObject()调用的是getEarlyBeanReference()如果该 Bean 需要 AOP 代理这里就会提前创建代理对象。3.4 关键源码doCreateBean() — 暴露到三级缓存// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) { // 1. 实例化 Bean调用构造器 BeanWrapper instanceWrapper createBeanInstance(beanName, mbd, args); Object bean instanceWrapper.getWrappedInstance(); // 2. 提前暴露 Bean 的早期引用 — 解决循环依赖的关键 boolean earlySingletonExposure (mbd.isSingleton() this.allowCircularReferences isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { addSingletonFactory(beanName, () - getEarlyBeanReference(beanName, mbd, bean)); } // 3. 属性填充依赖注入在这里发生 Object exposedObject bean; populateBean(beanName, mbd, instanceWrapper); // 4. 初始化 Bean exposedObject initializeBean(beanName, exposedObject, mbd); return exposedObject; }3.5 关键源码addSingletonFactory()// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry protected void addSingletonFactory(String beanName, ObjectFactory? singletonFactory) { synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { // 存入三级缓存 this.singletonFactories.put(beanName, singletonFactory); // 从二级缓存移除保证只在一个缓存中 this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } }3.6 完整流程简述面试话术Spring 创建 A先实例化 A调用构造器将 A 的 ObjectFactory 存入三级缓存A 属性填充时发现需要 B去创建 BB 实例化后存入三级缓存属性填充时发现需要 AB 调用 getBean(a)先查一级缓存没有再查二级缓存没有从三级缓存中找到 A 的 ObjectFactory调用 getObject() 获取 A 的早期引用将 A 的早期引用从三级缓存升级到二级缓存移除三级缓存中的 AB 拿到 A 的早期引用完成属性填充和初始化存入一级缓存回到 A拿到完整的 B完成属性填充和初始化存入一级缓存四、为什么是三级而非二级4.1 核心原因支持 AOP 代理延迟创建如果只有二级缓存在实例化后直接创建代理对象存入二级缓存。但问题是如果没有循环依赖AOP 代理应该在初始化后创建BeanPostProcessor#postProcessAfterInitialization而不是提前创建。三级缓存的作用ObjectFactory 是一个工厂lambda只有在真正发生循环依赖时才调用 getObject()。如果不存在循环依赖这个工厂永远不会被调用代理对象会在正常的初始化后阶段创建。4.2 对比分析flowchart TD subgraph 二级缓存方案 A2[实例化 A] -- B2[立即创建代理对象] B2 -- C2[代理对象存入二级缓存] C2 -- D2{是否发生循环依赖?} D2 --|是| E2[正常代理被使用] D2 --|否| F2[代理被创建但从未使用br/浪费性能 代理对象不对] end subgraph 三级缓存方案[三级缓存方案] A3[实例化 A] -- B3[ObjectFactory 存入三级缓存] B3 -- C3{是否发生循环依赖?} C3 --|是| D3[调用 getObject 创建代理br/存入二级缓存] C3 --|否| E3[三级缓存不调用br/代理在正常阶段创建] E3 -- F3[初始化后 AOP 创建代理br/BeanPostProcessor] end4.3 关键源码getEarlyBeanReference()// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject bean; if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) { for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) { // 如果需要 AOP 代理这里会提前创建代理对象 exposedObject bp.getEarlyBeanReference(exposedObject, beanName); } } return exposedObject; }面试话术三级缓存的 ObjectFactory 中调用的getEarlyBeanReference()会遍历所有SmartInstantiationAwareBeanPostProcessor如果该 Bean 需要 AOP 代理被 Transactional 或 Aspect 标注就会在这里提前创建代理对象。如果不需要代理直接返回原始 Bean。这就是延迟创建代理的含义。4.4 总结问题二级缓存三级缓存能否解决无 AOP 的循环依赖✅✅能否解决有 AOP 的循环依赖❌ 代理创建时机不对✅ 按需延迟创建无循环依赖时是否多余创建代理❌ 会提前创建✅ 不会设计理念简单直接延迟加载按需创建面试终极回答Spring 使用三级缓存而非二级缓存核心是为了处理 AOP 场景下的循环依赖。三级缓存的 ObjectFactory 实现了代理对象的延迟创建——只有在发生循环依赖时才提前生成代理没有循环依赖时代理在正常的初始化后阶段创建保证了代理创建的时机正确。五、构造器注入为何无法解决5.1 核心原因鸡生蛋问题构造器注入要求在实例化阶段就拿到依赖而 Spring 解决循环依赖的前提是先实例化再填充属性。构造器注入把这个前提打破了——A 的实例化依赖 BB 的实例化依赖 A双方都无法先实例化。创建 A需要 B 的构造器参数去创建 B需要 A 的构造器参数去创建 AA 正在创建中!抛出 BeanCurrentlyInCreationException5.2 源码层面的原因// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { // 构造器注入在这里解析依赖 // 如果依赖的 Bean 尚未实例化会调用 getBean() // 但 getBean 又会回到 createBeanInstance → 死循环 Constructor?[] ctors determineConstructorsFromBeanPostProcessors(bd, beanName); // ... 解析构造器参数 // 此时 A 和 B 都还没实例化完成无法互相提供 }关键点三级缓存的暴露addSingletonFactory发生在createBeanInstance之后但构造器注入的依赖解析发生在createBeanInstance之中。也就是说三级缓存还没来得及存构造器就已经需要依赖了。5.3 构造器循环依赖的报错信息org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name serviceA defined in file [...]: Unsatisfied dependency expressed through constructor parameter 0; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name serviceB: Requested bean is currently in creation: Is there an unresolvable circular reference?六、特殊场景分析6.1 Lazy 解决构造器循环依赖Component public class ServiceA { private final ServiceB serviceB; Autowired public ServiceA(Lazy ServiceB serviceB) { this.serviceB serviceB; } } Component public class ServiceB { private final ServiceA serviceA; Autowired public ServiceB(Lazy ServiceA serviceA) { this.serviceA serviceA; } }原理Lazy会让 Spring 注入一个代理对象而非真实 Bean。构造器阶段拿到的是代理对象的空壳不会触发真实 Bean 的创建。后续第一次调用代理对象的方法时代理对象才会去容器中获取真实 Bean此时真实 Bean 已经创建完成。6.2 Async 导致循环依赖失败Component public class ServiceA { Autowired private ServiceB serviceB; } Component public class ServiceB { Lazy Autowired private ServiceA serviceA; Async public void asyncMethod() { } }原因Async会给 ServiceB 创建 AOP 代理。在 ServiceB 的postProcessAfterInitialization阶段代理对象被创建。但这个代理对象和之前三级缓存中通过getEarlyBeanReference创建的早期引用不是同一个对象导致 Spring 发现最终对象和早期引用不一致抛出异常。解决方案在注入处加Lazy使用EnableAsync时设置proxyTargetClass trueSpring Boot 2.6 默认禁止循环依赖需通过spring.main.allow-circular-referencestrue开启6.3 原型 Bean 的循环依赖Component Scope(prototype) public class ServiceA { Autowired private ServiceB serviceB; } Component Scope(prototype) public class ServiceB { Autowired private ServiceA serviceA; }结论Spring不尝试解决原型 Bean 的循环依赖直接抛出异常。因为原型 Bean 每次获取都是新对象无法通过缓存机制管理。6.4 Spring Boot 2.6 默认禁止循环依赖Spring Boot 2.6 起默认禁止循环依赖# application.yml spring: main: allow-circular-references: false # 默认值为什么循环依赖本质上是设计问题Spring 团队认为开发者应该通过重构代码来消除循环依赖而不是依赖框架的补丁机制。禁止循环依赖能在开发阶段更早发现问题。如何开启设置spring.main.allow-circular-referencestrue。6.5 三种消除循环依赖的设计方案循环依赖 A-B-A如何消除?方案1: 提取公共逻辑方案2: 事件驱动解耦方案3: 中间人模式抽取 AB 共用逻辑到 ServiceCA-C, B-CA 发布事件, B 监听事件无需互相持有引用引入 Manager/CoordinatorA-Manager, B-Manager方案适用场景示例提取公共逻辑A 和 B 需要相同功能抽取 ServiceCA/B 都依赖 C事件驱动A 完成后通知 BA 发布ApplicationEventB 用EventListener监听中间人模式A 和 B 需要协调引入OrderService协调PaymentService和InventoryService七、自检Q1: 什么是循环依赖Spring 能解决哪些答循环依赖是两个或多个 Bean 互相持有对方引用。Spring 只能解决单例 Setter/字段注入的循环依赖构造器注入和原型 Bean 的循环依赖无法解决。Q2: 三级缓存分别是什么答一级缓存singletonObjects存放完整的 Bean二级缓存earlySingletonObjects存放早期暴露的 Bean已实例化但未完全初始化三级缓存singletonFactories存放 ObjectFactory用于延迟创建早期引用处理 AOPQ3: 为什么需要三级缓存二级不行吗答二级缓存在无循环依赖时会提前创建 AOP 代理导致代理创建时机错误。三级缓存的 ObjectFactory 实现了按需延迟创建——只有发生循环依赖时才调用 getObject() 创建代理没有循环依赖时代理在正常的 BeanPostProcessor 阶段创建。Q4: 构造器注入的循环依赖为什么无法解决答构造器注入的依赖解析发生在实例化阶段而三级缓存的暴露在实例化之后。也就是说还没来得及把 Bean 存入三级缓存构造器就已经需要依赖了形成死循环。Q5: Lazy 如何解决构造器循环依赖答Lazy注入的是代理对象而非真实 Bean。构造器拿到代理的空壳不会触发真实 Bean 的创建。后续调用方法时代理才去容器获取真实 Bean。核心源码路径速查类方法作用DefaultSingletonBeanRegistrygetSingleton(String, boolean)三级缓存查找逻辑DefaultSingletonBeanRegistryaddSingletonFactory()存入三级缓存DefaultSingletonBeanRegistryaddSingleton()存入一级缓存AbstractAutowireCapableBeanFactorydoCreateBean()暴露三级缓存的入口AbstractAutowireCapableBeanFactorygetEarlyBeanReference()三级缓存的 ObjectFactory 执行逻辑