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

Spring如何巧妙解决循环依赖问题

news 2025/9/16 13:40:50

什么是循环依赖？

循环依赖是指两个或多个Bean之间相互依赖，形成闭环的情况。例如：AService依赖BService，而BService又依赖AService。这种场景下，传统的创建顺序无法满足依赖注入的要求。

Spring的三级缓存机制

Spring通过三级缓存机制优雅地解决了循环依赖问题：

1. 第一级缓存：singletonObjects

存储完全初始化完成的单例Bean
这里的Bean是经过完整生命周期处理的（包括AOP代理）

2. 第二级缓存：earlySingletonObjects

存储提前暴露的Bean引用（早期引用）
这些Bean尚未完成完整初始化，但可以用于解决循环依赖

3. 第三级缓存：singletonFactories

存储Bean的ObjectFactory（工厂对象）
通过工厂可以获取Bean的早期引用，必要时创建代理对象

解决循环依赖的详细流程

场景：AService ←→ BService 相互依赖

java

// AService 依赖 BService
@Service
public class AService {@Autowiredprivate BService bService;
}// BService 依赖 AService
@Service
public class BService {@Autowiredprivate AService aService;
}

解决步骤：

开始创建AService
- creatingSet.add('AService') - 标记AService正在创建
- 实例化AService普通对象
AService需要注入BService
- 从单例池获取BService，不存在则开始创建BService
创建BService
- creatingSet.add('BService') - 标记BService正在创建
- 实例化BService普通对象
- BService需要注入AService
BService获取AService
- 从单例池获取AService，不存在
- 检查creatingSet发现AService正在创建（循环依赖 detected!）
- 从三级缓存获取AService的ObjectFactory
- 执行工厂方法：getEarlyBeanReference() → 必要时创建AService代理对象
- 将结果存入二级缓存earlySingletonObjects，并从三级缓存移除工厂
BService继续初始化
- 注入AService的早期引用（可能是代理对象）
- 完成其他属性填充
- 执行AOP（如果需要）
- 将完整BService存入单例池
AService继续初始化
- 注入已创建的BService
- 完成其他属性填充
- 执行AOP（但发现已提前AOP，直接使用早期引用）
- 将完整AService存入单例池

关键源码分析

1. 添加单例工厂

java

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);}}
}

在doCreateBean()方法中，Spring会提前暴露Bean的工厂：

java

// 为了解决循环依赖提前缓存单例创建工厂
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

2. 获取单例Bean的逻辑

java

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 1. 从一级缓存查找Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 2. 从二级缓存查找singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) {// 3. 从三级缓存查找并创建早期引用ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();// 移动到二级缓存this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;
}

3. 提前AOP处理

java

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {// 如果需要AOP，则创建代理对象Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);if (specificInterceptors != DO_NOT_PROXY) {Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));return proxy;}return bean;
}