Spring的循环依赖

什么是Spring的循环依赖

Spring 的循环依赖问题指的是在 Spring 容器中，两个或多个 Bean 之间存在相互依赖关系，形成了一个循环依赖的情况。这种情况下，当 Spring 容器初始化时，无法正确地完成 Bean 的创建和依赖注入，导致程序出现错误或无法正常运行。

下面是通过GPT生成的一个例子来说明 Spring 的循环依赖问题：

假设有两个类 A 和 B，它们相互依赖：

public class A {
    private B b;

    public A(B b) {
        this.b = b;
    }
}

public class B {
    private A a;

    public B(A a) {
        this.a = a;
    }
}

在 Spring 容器中，我们定义了这两个 Bean：

<bean id="a" class="com.example.A">
    <constructor-arg ref="b"/>
</bean>

<bean id="b" class="com.example.B">
    <constructor-arg ref="a"/>
</bean>

当 Spring 容器初始化时，它会先创建 A 的实例，然后创建 B 的实例。但是在创建 A 的实例时，需要注入一个 B 的实例，而 B 的实例又需要注入一个 A 的实例，这样就形成了循环依赖。

由于循环依赖的存在，Spring 容器无法在初始化时正确地完成 Bean 的创建和依赖注入。它会尝试创建 A 的实例，但由于需要注入 B 的实例，而 B 的实例又需要注入 A 的实例，这样就陷入了一个无限循环的过程，最终导致栈溢出错误。

Spring解决循环依赖依靠的是Bean的“中间态”这个概念，而这个中间态指的是已经实例化，但还没初始化的状态。而构造器是完成实例化的，所以构造器的循环依赖无法解决

对Bean的创建最为核心三个方法解释如下：

• createBeanInstance：例化，其实也就是调用对象的构造方法实例化对象
• populateBean：填充属性，这一步主要是对bean的依赖属性进行注入(@Autowired)
• initializeBean：回到一些形如initMethod、InitializingBean等方法

从对单例Bean的初始化可以看出，循环依赖主要发生在第二步（populateBean），也就是field属性注入的处理。

Spring 使用了三级缓存来解决循环依赖问题，这三级缓存分别是 singletonFactories、earlySingletonObjects 和 singletonObjects。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    ...
    // 从上至下 分表代表这“三级缓存”
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
    ...
    
    /** Names of beans that are currently in creation. */
    // 这个缓存也十分重要：它表示bean创建过程中都会在里面呆着~
    // 它在Bean开始创建时放值，创建完成时会将其移出~
    private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** Names of beans that have already been created at least once. */
    // 当这个Bean被创建完成后，会标记为这个 注意：这里是set集合 不会重复
    // 至少被创建了一次的  都会放进这里~~~~
    private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

1. singletonFactories(三级缓存)：在创建 Bean 的过程中，Spring 会将正在创建的 Bean 实例放入 singletonFactories 缓存中。这个缓存保存了正在创建但尚未完成的 Bean 实例。
2. earlySingletonObjects(二级缓存)：当 Bean 的创建过程中发现循环依赖时，Spring 会将已经创建完成的 Bean 实例放入 earlySingletonObjects 缓存中。这个缓存保存了已经创建完成但尚未完成依赖注入的 Bean 实例。
3. singletonObjects(一级缓存)：当 Bean 的依赖注入完成后，Spring 会将 Bean 实例放入 singletonObjects 缓存中。这个缓存保存了已经创建完成且依赖注入完成的 Bean 实例。（该级存放的是完整的bean实例，已经实例化和初始化好的实例）

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    ...
    @Override
    @Nullable
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
    ...
    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.contains(beanName);
    }
    protected boolean isActuallyInCreation(String beanName) {
        return isSingletonCurrentlyInCreation(beanName);
    }
    ...
}

上述的代码逻辑为：

先从一级缓存singletonObjects中去获取(如果获取到就直接retrun)。
如果获取不到或者对象正在创建中(isSingletonCurrentlyInCreation() )，那就再从二级缓存earlySingletonObjects中获取(如果获取到就直接retrun)。
如果还是获取不到，且允许singletonFactories(allowEarlyReference = true)通过getObject()获取，
就从三级缓存singletonFactory.getObject()获取(如果获取到了就从singletonFactories中移除，并且放进earlySingletonObjects。
其实也就是从三级缓存移动(是剪切、并不是复制)到了二级缓存)。

加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决！
getSingleton()从缓存里获取单例对象步骤分析可知，Spring解决循环依赖的诀窍：就在于singletonFactories这个三级缓存。
这个Cache里面都是ObjectFacotry，它是解决问题的关键。

从上述分析也能发现，解决Spring的循环依赖问题是通过三级缓存的方式来解决，并且只能是通过setter注入的方式来解决。

而通过 setter 的方式注入可以解决循环依赖的问题，原因如下：

1. Spring 容器在创建 Bean 实例后，会先调用无参构造函数创建一个空对象，然后再通过 setter 方法进行属性注入。这样，在创建 Bean 实例时就不会陷入循环依赖的死循环。
2. 通过 setter 方法注入属性时，可以先创建一个空对象，然后再通过 setter 方法将依赖的 Bean 注入进去。这样，在创建 Bean 实例时就可以解决循环依赖的问题。

然而，循环依赖问题是一种设计上的坏味道，应该尽量避免。如果在项目中出现了循环依赖问题，建议重新审视设计，尝试解耦相关的类，以避免出现循环依赖的情况。

为什么要用三级缓存而不是二级缓存

可以看到三级缓存各自保存的对象，这里重点关注二级缓存earlySingletonObjects和三级缓存singletonFactory，一级缓存可以进行忽略。前面我们讲过先实例化的bean会通过ObjectFactory半成品提前暴露在三级缓存中
所以如果没有AOP的话确实可以两级缓存就可以解决循环依赖的问题，如果加上AOP，两级缓存是无法解决的，不可能每次执行singleFactory.getObject()方法都给我产生一个新的代理对象，所以还要借助另外一个缓存来保存产生的代理对象

参考文章：spring循环依赖与三级缓存