【Spring】Spring循环依赖（超重要！！）

目录

什么是循环依赖问题

循环依赖具体是怎么解决的

具体的解决步骤：

通俗实例：      

严谨的循环依赖解决图例

为什么使用的是三级缓存，二级缓存不够用吗？

---

什么是循环依赖问题

        Spring的循环依赖是指在Bean之间存在相互依赖关系，形成一个闭环的情况。简单来说，Bean A依赖于Bean B，同时Bean B也依赖于Bean A，这就构成了循环依赖。

        下面是一个示例，展示了Spring中循环依赖的情况：

// Class A
public class A {
   private B b;
   
   public A() {
   }
   
   public void setB(B b) {
       this.b = b;
   }
   
   public void doSomething() {
       System.out.println("Class A is doing something.");
   }
}

// Class B
public class B {
    private A a;
    
    public B() {
    }
    
    public void setA(A a) {
        this.a = a;
    }
    
    public void doSomethingElse() {
        System.out.println("Class B is doing something else.");
    }
}

在上述示例中，类A依赖于类B的实例，而类B又依赖于类A的实例。当我们使用Spring容器来创建这两个类的实例时，就会发生循环依赖的情况。

<!-- XML 配置文件 -->
<bean id="a" class="com.example.A">
    <property name="b" ref="b" />
</bean>

<bean id="b" class="com.example.B">
    <property name="a" ref="a" />
</bean>

在上述配置中，我们定义了Bean A和Bean B，并通过属性注入方式使它们相互引用。

如果我们运行以下代码来获取Bean A的实例：

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    A a = context.getBean(A.class);
    a.doSomething();
}

        在这种情况下，Spring会尝试创建Bean A的实例。但是由于循环依赖，它会先创建一个空的Bean A，并将其放入缓存中。然后，Spring继续创建依赖的Bean B，但因为它也依赖Bean A，Spring会从缓存中获取Bean A的实例，并将其注入到Bean B中。

        接下来，Spring回到缓存中，将属性注入到之前创建的Bean A实例中，完成Bean A的初始化。最后，Bean A的完全初始化实例返回给调用方。

循环依赖具体是怎么解决的

Spring使用了三级缓存以及"提前曝光"的机制来解决循环依赖的问题。

具体的解决步骤：

1. 创建空对象：当Spring容器发现循环依赖时，会先创建一个空对象作为Bean A或Bean B的临时实例，并将其放入第一级缓存中。

2. 属性注入：然后，Spring会继续创建被循环依赖的Bean的其他属性，并将这些属性注入到临时实例中。

3. 提前曝光：在注入属性期间，如果发现循环依赖的Bean已经存在于第一级缓存中，Spring会将那个早期的实例提前曝光到第二级缓存中，以供其他需要依赖它的Bean使用。

4. 创建完整实例：完成属性注入后，Spring会将临时实例传递给Bean的初始化方法，并执行初始化操作。初始化完成后，循环依赖的Bean就成为一个完整的可用实例了。

5. 缓存实例：最后，Spring将这个完整的Bean实例放入第三级缓存中，以供后续使用。

通俗实例：      

        假设有两个人，小明和小红，他们互相依赖对方来完成一项任务。小明需要小红的帮助才能完成自己的任务，而小红也需要小明的帮助才能完成自己的任务。这就形成了一个循环依赖的情况。

为了解决这个问题，他们采取以下步骤：

1. 小明向小红发出请求：小明首先联系小红，告诉她自己需要她的帮助来完成任务。

2. 小红创建一个"空的"小明实例：小红收到请求后，会先创建一个空的小明实例，并进行标记，表示这是一个临时的、不完整的实例。

3. 小红继续进行自己的任务：在创建小明实例的同时，小红并不会等待小明的实例完成，而是继续进行自己的任务。

4. 小明提供帮助：在小红继续进行自己的任务期间，小明得到了小红的帮助，完成了自己的任务。

5. 小红注入属性：当小明的任务完成后，小红会将小明实例中需要的属性注入进去，使得小明的实例成为一个完整的、可用的实例。

6. 小红完成任务：接着，小红继续进行自己的任务，并顺利完成。

大概就是这样一个流程

严谨的循环依赖解决图例

为什么使用的是三级缓存，二级缓存不够用吗？

假设有两个类 A 和 B，它们相互依赖对方来完成初始化。A 类依赖于 B 类的实例，而 B 类也依赖于 A 类的实例。这种情况下，如果只使用二级缓存，会导致属性注入的顺序错误，从而无法正确解决循环依赖。

具体示例：

1. 创建 A 类实例：首先，Spring 会尝试创建 A 类的实例，并将其放入二级缓存中。
2. 创建 B 类实例：接下来，Spring 发现 B 类依赖 A 类的实例，于是尝试创建 B 类的实例，并将其放入二级缓存中。
3. 属性注入：在属性注入过程中，由于 B 类的实例已经在二级缓存中，Spring 尝试从缓存中获取 B 类的实例，并将其注入到 A 类的实例中。但此时 A 类的实例还没有完全初始化，因此导致注入的 A 类实例不完整。
4. 初始化 A 类：接着，Spring 继续初始化 A 类的实例并执行初始化操作，但由于 A 类实例的属性注入不完整，可能导致初始化失败或产生不正确的结果。
5. 初始化 B 类：最后，Spring 继续初始化 B 类的实例，但由于 B 类实例依赖 A 类的实例，而 A 类实例又没有正确注入，导致 B 类的实例无法正确初始化。

由于二级缓存只能缓存已经完成初始化的 Bean，不能解决属性注入时的循环依赖问题。

        而三级缓存相比二级缓存能够正常应对循环依赖的原因在于它引入了一个"早期曝光"的机制，可以在属性注入之前提前暴露早期实例。

        具体来说，在三级缓存中，当检测到循环依赖时，Spring 会首先创建一个早期对象（Early Object），并将其放入三级缓存中。早期对象是一个未完成初始化的对象，其中的属性可能尚未注入完全。

通过三级缓存的机制，能够解决从二级缓存获取实例时属性注入顺序错误的问题。

具体流程：

1. 创建 A 类早期对象：首先，Spring 创建 A 类的早期对象，并将其放入三级缓存中。

2. 创建 B 类实例：接着，Spring 发现 B 类依赖 A 类的实例，于是尝试创建 B 类的实例，并将其放入二级缓存中。

3. 属性注入：在属性注入过程中，Spring 从二级缓存中获取 B 类的实例，并将其注入到 A 类的早期对象中。虽然 A 类的早期对象的属性注入仍不完整，但关键是 B 类实例已经被注入。

4. 完成 A 类实例化：接下来，Spring 继续完成 A 类的实例化，并执行初始化操作。由于 B 类实例已经注入，A 类能够正确地访问 B 类的属性。

5. 创建 B 类早期对象：当初始化 A 类后，Spring 检测到 B 类也存在循环依赖，于是创建 B 类的早期对象，并将其放入三级缓存中。

6. 属性注入：在属性注入过程中，Spring 从三级缓存中获取 B 类的早期对象，并将其注入到 A 类的实例中。这样，A 类实例的属性注入得以完成。

7. 完成 B 类实例化：最后，Spring 继续完成 B 类的实例化，并执行初始化操作。由于 A 类实例已经注入，B 类能够正确地访问 A 类的属性。