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

Spring--循环依赖以及三级缓存详解

news 2025/7/6 21:58:21

一、什么是循环依赖

循环依赖是指两个或多个Bean之间相互依赖，形成一个闭环。例如：

Bean A 依赖 Bean B
Bean B 依赖 Bean A

示意图如下：

在大型应用中，还可能出现更复杂的循环依赖：

Bean A 依赖 Bean B
Bean B 依赖 Bean C
Bean C 依赖 Bean A

二、为什么循环依赖是个问题

在普通的对象创建过程中，循环依赖会导致类似"鸡生蛋，蛋生鸡"的问题：

创建A时，发现依赖B，转而去创建B
创建B时，发现依赖A，但A还未创建完成
系统陷入死循环

在没有特殊处理的情况下，这将导致应用启动失败。

三、Spring如何解决循环依赖

Spring通过巧妙的设计，采用了三级缓存机制来解决循环依赖问题。这一机制主要针对单例作用域(singleton scope)的Bean。

注意：Spring无法解决以下循环依赖场景：

构造器注入的循环依赖:

实例化与初始化顺序问题：Spring解决循环依赖的关键在于先实例化对象，再进行属性注入。但构造器注入是在实例化阶段就需要依赖对象，这导致了"鸡蛋-鸡"的悖论。
三级缓存机制失效：三级缓存机制依赖于先创建实例再暴露早期引用，但构造器注入需要在实例创建时就提供依赖，此时还没有可暴露的早期引用。

原型模式(prototype)的循环依赖：

缓存机制不适用：三级缓存机制只应用于单例Bean。原型Bean每次获取都会创建新实例，不会被缓存。
生命周期管理差异：单例Bean由容器全程管理，而原型Bean创建后由调用者管理，Spring无法跟踪其完整生命周期。

作用域为request、session等的循环依赖：

生命周期绑定：这些作用域的Bean生命周期与HTTP请求或会话绑定，不是应用级别的单例。
延迟创建特性：这些作用域的Bean通常使用代理模式延迟创建，真正的Bean实例是在请求或会话开始时才创建。
缓存隔离：每个请求/会话有自己的Bean实例，不同请求/会话间的Bean无法共享，三级缓存在这种情况下无法正常工作。

四、三级缓存详解

Spring的三级缓存定义在DefaultSingletonBeanRegistry类中：

/** 一级缓存：完成初始化的单例Bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** 二级缓存：提前暴露的单例对象，尚未完成初始化 */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);/** 三级缓存：单例工厂对象，用于创建Bean并进行AOP处理 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

各级缓存的作用

一级缓存(singletonObjects)
- 存放完全初始化好的Bean
- Bean已经完成属性注入和初始化方法(如initMethod)的调用
- 可以直接使用
二级缓存(earlySingletonObjects)
- 存放原始Bean对象，尚未完成属性注入和初始化
- 用于解决循环依赖场景下的对象引用问题
三级缓存(singletonFactories)
- 存放Bean的工厂对象
- 主要作用是处理AOP代理对象的创建
- 如果没有AOP，三级缓存可以被二级缓存替代

五、循环依赖解决流程

以A、B两个Bean循环依赖为例，Spring解决流程如下：

创建A的过程：
- 实例化A对象(此时尚未属性注入)
- 将A的创建工厂放入三级缓存
- 进行属性注入，发现依赖B
创建B的过程：
- 实例化B对象
- 将B的创建工厂放入三级缓存
- 进行属性注入，发现依赖A
- 尝试从一级缓存获取A，失败
- 尝试从二级缓存获取A，失败
- 从三级缓存获取A的工厂，并使用工厂创建A的早期引用
- 将A的早期引用从三级缓存升级到二级缓存
- B完成属性注入(注入A的早期引用)
- B完成初始化，放入一级缓存
完成A的创建：
- 继续A的属性注入(注入已创建完成的B)
- A完成初始化，放入一级缓存

六、源码解析

获取Bean的主要流程

Spring在AbstractBeanFactory.doGetBean()方法中获取Bean：

protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {// 尝试从缓存获取Object sharedInstance = getSingleton(beanName);// 如果缓存中没有，则创建Beanif (sharedInstance == null) {// 创建Bean的过程sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);} catch (BeansException ex) {// ...}});}// ...
}

三级缓存的核心实现

DefaultSingletonBeanRegistry.getSingleton()方法展示了三级缓存的使用：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 一级缓存查找Object singletonObject = this.singletonObjects.get(beanName);// 如果一级缓存没有，且当前Bean正在创建中if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 二级缓存查找singletonObject = this.earlySingletonObjects.get(beanName);// 如果二级缓存没有，且允许早期引用if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) {// 三级缓存查找ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 使用工厂创建对象singletonObject = singletonFactory.getObject();// 放入二级缓存this.earlySingletonObjects.put(beanName, singletonObject);// 从三级缓存移除this.singletonFactories.remove(beanName);}}}}return singletonObject;
}

添加到三级缓存的关键代码

在AbstractAutowireCapableBeanFactory.doCreateBean()方法中:

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {// 实例化BeanBeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);final Object bean = instanceWrapper.getWrappedInstance();// 是否需要提前暴露（解决循环依赖）boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {// 添加到三级缓存addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// 属性注入和初始化populateBean(beanName, mbd, instanceWrapper);Object exposedObject = initializeBean(beanName, exposedObject, mbd);// ...
}

七、为什么需要三级缓存？

很多人疑惑：如果只是解决循环依赖，为什么需要三级缓存？二级缓存不够吗？

答案与Spring的AOP机制有关：

没有AOP时：二级缓存足够解决循环依赖
- 一级缓存存完整Bean
- 二级缓存存早期Bean
有AOP时：需要三级缓存
- Spring不确定哪些Bean需要代理，只能在Bean生命周期后期才能确定
- 三级缓存中的ObjectFactory提供了一个延迟处理的机制
- 当出现循环依赖时，通过ObjectFactory.getObject()提前进行AOP代理
- 确保注入的始终是符合预期的对象（原始对象或代理对象）

示例分析

假设有两个类：

@Component
public class A {@Autowiredprivate B b;public void methodA() {System.out.println("Method A");}
}@Component
public class B {@Autowiredprivate A a;public void methodB() {System.out.println("Method B");}
}

循环依赖解决过程：