从原理到源码深度剖析Spring循环依赖-CSDN博客

一、循环依赖基础概念

1.1 什么是循环依赖

循环依赖是指两个或多个Bean相互依赖，形成一个闭环引用关系。例如：

// Bean A 依赖 Bean B
public class A {
    @Autowired
    private B b;
}

// Bean B 依赖 Bean A
public class B {
    @Autowired
    private A a;
}

这种A→B→A的依赖关系就构成了循环依赖。

1.2 Spring中的循环依赖类型

Spring中的循环依赖主要分为三种情况：

构造器循环依赖：通过构造器注入形成的循环依赖
Setter/Field循环依赖：通过setter方法或字段注入形成的循环依赖
原型(prototype)作用域的循环依赖

Spring只能解决Setter/Field循环依赖，无法解决构造器循环依赖和原型作用域的循环依赖。

二、Spring解决循环依赖的核心原理

2.1 三级缓存机制

Spring通过三级缓存来解决循环依赖问题：

一级缓存(singletonObjects)：存放完全初始化好的Bean
二级缓存(earlySingletonObjects)：存放早期暴露的Bean（已实例化但未完成属性填充和初始化）
三级缓存(singletonFactories)：存放Bean工厂，用于生成早期暴露的Bean

2.2 解决循环依赖的关键步骤

实例化：创建Bean的原始对象（此时属性还未填充）
提前暴露引用：将刚实例化的Bean放入三级缓存
属性填充：填充Bean的属性依赖
初始化：执行初始化回调方法
加入一级缓存：将完全初始化好的Bean放入一级缓存，清除二、三级缓存

三、源码深度解析

3.1 核心类与关键方法

循环依赖处理主要涉及以下核心类：

DefaultSingletonBeanRegistry：管理单例Bean的注册和获取
AbstractAutowireCapableBeanFactory：Bean创建和初始化的核心实现
AbstractBeanFactory：Bean工厂的抽象基类

3.2 三级缓存定义

在DefaultSingletonBeanRegistry中定义了三级缓存：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // 一级缓存：完全初始化好的单例Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    // 三级缓存：单例工厂缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    // 二级缓存：早期暴露的单例Bean
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    
    // 正在创建中的Bean名称集合
    private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

3.3 Bean创建流程

核心流程在AbstractAutowireCapableBeanFactory.doCreateBean()方法中：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    
    // 1. 实例化Bean
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    Object bean = instanceWrapper.getWrappedInstance();
    
    // 2. 判断是否需要提前暴露早期引用
    boolean earlySingletonExposure = (mbd.isSingleton() && 
            this.allowCircularReferences && 
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 3. 将Bean工厂添加到三级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    
    // 4. 属性填充（可能触发依赖Bean的创建）
    populateBean(beanName, mbd, instanceWrapper);
    
    // 5. 初始化Bean
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    return exposedObject;
}

3.4 提前暴露引用的关键方法

addSingletonFactory方法将Bean工厂放入三级缓存：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
        }
    }
}

3.5 获取Bean的核心流程

当需要获取一个Bean时，会调用DefaultSingletonBeanRegistry.getSingleton()方法：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 首先尝试从一级缓存获取
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 2. 从二级缓存获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 3. 从三级缓存获取Bean工厂并创建早期引用
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    // 将早期引用放入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

3.6 循环依赖解决示例

以A和B的循环依赖为例：

创建A时，先实例化A，然后将A的工厂放入三级缓存
填充A的属性时发现需要B，开始创建B
创建B时实例化B，将B的工厂放入三级缓存
填充B的属性时发现需要A，从三级缓存获取A的早期引用
B完成创建后，A可以完成属性填充和初始化
最后A和B都创建完成，放入一级缓存

四、特殊场景分析

4.1 构造器循环依赖为何无法解决

构造器注入的循环依赖无法解决，因为在调用构造器之前无法提前暴露引用。Spring会在AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors()方法中检测构造器循环依赖，并抛出BeanCurrentlyInCreationException。

4.2 原型Bean的循环依赖为何无法解决

原型Bean每次都会创建新实例，Spring不会缓存原型Bean的引用，因此无法通过提前暴露引用的方式解决循环依赖。

4.3 AOP代理与循环依赖

当Bean需要被AOP代理时，Spring通过SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference()方法提前返回代理对象：

// AbstractAutoProxyCreator中的实现
public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    // 创建代理对象
    return wrapIfNecessary(bean, beanName, cacheKey);
}