一文彻底搞懂spring循环依赖

1. 什么是循环依赖

Spring 中的循环依赖是指两个或多个 Bean 之间相互依赖，形成一个循环引用的情况。在 Spring 容器中，循环依赖通常指的是单例（Singleton）作用域的 Bean 之间的循环引用。

循环依赖可能会导致以下问题：

1.提前暴露不完整的 Bean：如果 A 依赖于 B，而 B 又依赖于 A，那么在初始化过程中，A 可能会拿到一个尚未完成初始化的 B 对象，导致对象状态不完整或不一致。
2.无限循环：如果循环依赖链路过长或者存在循环引用关系，可能会导致 Bean 初始化的时候发生死循环，最终导致堆栈溢出。

2. Spring怎么解决循环依赖

Spring 解决循环依赖的机制主要基于三级缓存和提前曝露半初始化的 Bean 的思想。具体步骤如下：

1.实例化对象并放入缓存

当 Spring 容器创建 Bean 时，会先实例化对象，然后将对象放入第一级缓存（singletonObjects）中。此时对象还未完全初始化。

2.设置对象引用

Spring 将对象放入第二级缓存（earlySingletonObjects），并设置对象的引用。这时候对象已经可以被其他对象引用，但仍未完成初始化。

3.提前曝光半初始化的 Bean

如果 Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A，Spring 在创建 Bean A 时，会提前曝光一个半初始化的 Bean A 到第二级缓存中。这个半初始化的 Bean A 具有 Bean A 的代理对象，可以提供给 Bean B 使用。

4.完成 Bean 的初始化

Spring 继续初始化 Bean B，当 Bean B 初始化完成后，Spring 再回头来完成 Bean A 的初始化。这时，Bean A 已经可以通过代理对象访问到 Bean B。

5.将对象移至第三级缓存

当 Bean A 和 Bean B 都初始化完成后，Spring 将它们从第二级缓存移动到第三级缓存（singletonFactories）中，同时清除第一级和第二级缓存中的对象。

public class DefaultSingletonBeanRegistry {
    
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(64); // 第一级缓存
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 第二级缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 第三级缓存
    
    public Object getSingleton(String beanName) {
        // 1. 从第一级缓存中获取对象
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }
        
        // 2. 从第二级缓存中获取对象
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }
        
        // 3. 从第三级缓存中获取对象工厂，并使用工厂创建对象
        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
        if (singletonFactory != null) {
            synchronized (this.singletonObjects) {
                singletonObject = singletonFactory.getObject();
                this.earlySingletonObjects.put(beanName, singletonObject);
                this.singletonFactories.remove(beanName);
            }
            // 4. 完成 Bean 的初始化
            initializeBean(beanName, singletonObject);
            // 5. 将对象移至第一级缓存
            addToSingletons(beanName, singletonObject);
            return singletonObject;
        }
        
        return null;
    }
    
    private void initializeBean(String beanName, Object singletonObject) {
        // 初始化 Bean 的逻辑，包括填充属性、调用初始化方法等
    }
    
    private void addToSingletons(String beanName, Object singletonObject) {
        this.singletonObjects.put(beanName, singletonObject);
    }
}

在这段代码中，模拟了 Spring 的 DefaultSingletonBeanRegistry 类，其中包含了三级缓存 singletonObjects、earlySingletonObjects 和 singletonFactories。当获取单例 Bean 时，首先会从第一级缓存中获取，如果没有找到则尝试从第二级缓存中获取，如果还没有则尝试从第三级缓存中获取对象工厂，并使用工厂创建对象。创建过程中会将对象暂时放入第二级缓存中，等待完成初始化后再移至第一级缓存中。

3. 无法处理的循环依赖

Spring 的循环依赖处理机制无法处理以下两种情况：

1.构造器循环依赖

如果 Bean A 的构造函数依赖于 Bean B，而 Bean B 的构造函数又依赖于 Bean A，则无法通过 Spring 的循环依赖处理机制解决。这是因为在创建 Bean 的过程中，构造函数的调用是在对象实例化之前发生的，此时无法确定构造函数所需的依赖对象是否已经创建，从而导致循环依赖无法被解决。

// BeanA.java
public class BeanA {
    private BeanB beanB;

    public BeanA(BeanB beanB) {
        this.beanB = beanB;
    }
}

// BeanB.java
public class BeanB {
    private BeanA beanA;

    public BeanB(BeanA beanA) {
        this.beanA = beanA;
    }
}

BeanA 的构造函数依赖于 BeanB，而 BeanB 的构造函数又依赖于 BeanA，构成了构造器循环依赖。

2.原型 Bean 属性注入循环依赖

对于原型（prototype）作用域的 Bean，Spring 容器在创建时不会缓存对象实例，而是在每次请求时都会创建一个新的实例。因此，如果原型 Bean A 的某个属性依赖于原型 Bean B，而 Bean B 的某个属性又依赖于 Bean A，这种循环依赖无法通过 Spring 的循环依赖处理机制解决。这是因为 Spring 容器无法在创建原型 Bean 时提前暴露半初始化的对象，也无法缓存原型 Bean 的实例。

// PrototypeBeanA.java
@Scope("prototype")
public class PrototypeBeanA {
    private PrototypeBeanB beanB;

    public void setBeanB(PrototypeBeanB beanB) {
        this.beanB = beanB;
    }
}

// PrototypeBeanB.java
@Scope("prototype")
public class PrototypeBeanB {
    private PrototypeBeanA beanA;

    public void setBeanA(PrototypeBeanA beanA) {
        this.beanA = beanA;
    }
}

PrototypeBeanA 的属性 beanB 依赖于 PrototypeBeanB，而 PrototypeBeanB 的属性 beanA 又依赖于 PrototypeBeanA，构成了原型 Bean 属性注入循环依赖。