springboot的循环依赖问题描述及解决方案

一.了解循环依赖的场景

在Spring Boot中，循环依赖是指两个或多个Bean之间相互依赖，导致它们无法正确地创建和注入。循环依赖可能会导致应用程序无法启动或出现其他异常。

在以下情况下，您可能需要显式设置循环依赖：

1. 两个Bean相互依赖：当两个Bean相互依赖，并且没有其他Bean可以打破这种依赖关系时，您需要显式设置循环依赖。例如，类A依赖于类B，而类B又依赖于类A。
2. 使用@Autowired注解：当您使用@Autowired注解将一个Bean注入到另一个Bean中时，如果它们之间存在循环依赖，您需要显式设置循环依赖。

下面是一个简单的流程图和示意图来解释循环依赖：

流程图：

java复制代码

Start -> A -> B -> A (循环依赖) -> Error

在这个例子中，类A依赖于类B，类B又依赖于类A，形成了一个循环依赖关系。如果没有显式设置循环依赖，Spring容器在启动时就会抛出异常，因为无法正确地创建和注入这两个Bean。

为了解决这个问题，您可以使用@Autowired注解显式设置循环依赖。这样做可以让Spring容器自动处理循环依赖关系，并确保这两个Bean能够正确地创建和注入。例如：

java复制代码

@Service public class A { @Autowired private B b; } @Service public class B { @Autowired private A a; }

 

 

在这个例子中，通过使用@Autowired注解显式设置循环依赖，Spring容器可以正确地创建和注入类A和类B的实例。

二.如何判断系统是否产生了循环依赖

判断系统是否产生了循环依赖，可以通过以下几种方法进行检测：

1. 观察法：观察系统中的依赖关系，看是否存在某个或某些Bean反复依赖其他Bean，并且无法正常完成初始化，这可能是循环依赖的迹象。
2. 日志法：在系统中的关键位置添加日志记录，跟踪Bean的创建和注入过程。如果发现日志中存在循环依赖的线索，例如多个Bean相互依赖导致的创建顺序循环，则可以确定存在循环依赖问题。
3. 调试法：使用调试工具，例如IDE的调试功能，设置断点并逐步执行代码，以观察是否存在循环依赖的情况。在调试过程中，可以检查调用栈和变量信息，看是否存在多个Bean相互等待对方完成初始化的情况。
4. 工具法：使用专门的循环依赖检测工具，例如Java字节码分析工具如ASM、Javassist等，来检测系统中的循环依赖问题。根据工具的输出结果，可以确定是否存在循环依赖问题。
5. 程序代码法：编写程序代码进行循环依赖检测。可以使用Java语言或其他编程语言编写循环依赖检测程序，利用反射机制获取系统中的Bean信息，并检查它们之间的依赖关系是否存在循环。

具体步骤如下：

以下是上述5种方法的详细步骤及使用例子：

1. 观察法：

步骤：

1. 在系统运行过程中，观察应用程序的行为。
2. 特别注意那些无法正常初始化的Bean，看它们是否在等待其他Bean的初始化。
3. 观察日志输出，查找循环依赖的相关信息。

例子：
假设有两个Bean A和B相互依赖，当Bean A尝试初始化时，它需要依赖Bean B的实例，而Bean B的初始化又需要Bean A的实例。这就会导致循环依赖的问题。通过观察应用程序的行为和日志输出，可以发现Bean A和Bean B在初始化时相互等待，无法正常完成初始化。

1. 日志法：

步骤：

1. 在应用程序的关键位置添加日志记录，例如在Bean的初始化方法中。
2. 运行应用程序并观察日志输出。
3. 查找循环依赖的线索，例如多个Bean相互依赖导致的创建顺序循环。

例子：
在Spring框架中，可以在Bean的初始化方法中添加日志记录，例如：

java复制代码

@Component 
public class ExampleBean { @Autowired private AnotherBean anotherBean; public void init() { System.out.println("Creating exampleBean..."); // 其他初始化代码 } 
}

在日志输出中，可以观察到类似以下信息：
Creating exampleBean...Creating anotherBean...Creating exampleBean...Creating anotherBean...(无限循环)
这说明存在循环依赖的问题。

1. 调试法：

步骤：

1. 使用调试工具打开应用程序，例如在IDE中打开调试视图。
2. 在调试视图中找到与Bean创建和注入相关的类或方法，并设置断点。
3. 继续运行应用程序，当断点触发时，调试工具将暂停执行并允许你检查当前的变量、调用栈等信息。
4. 观察调用栈和变量信息，查找是否存在多个Bean相互等待对方完成初始化的情况。

例子：
在IDE中打开调试视图，找到与Bean创建和注入相关的类或方法，例如在Spring框架中的ApplicationContext类，并设置断点。继续运行应用程序，当断点触发时，查看调用栈信息。如果发现调用栈中存在多个Bean相互等待对方完成初始化的情况，则说明存在循环依赖的问题。

1. 工具法：

步骤：

1. 选择一个适合的循环依赖检测工具，例如Java字节码分析工具如ASM、Javassist等。
2. 根据工具的文档或API使用指南，编写自定义的检测脚本或程序。例如，可以使用ASM工具附带的API编写一个检测循环依赖的程序。

三.解决循环依赖的几种方式

Spring Boot解决循环依赖的方法有多种，以下为每种方法提供详细解释和示例：

1. 使用构造器注入：

构造器注入是一种在构造器中通过参数传递依赖项的方式。这种方法可以确保所有依赖项在实例化Bean时就已经准备好，从而避免循环依赖的问题。例如：

java复制代码

@Service
public class A {private final B b;@Autowiredpublic A(B b) {this.b = b;}
}@Service
public class B {private final A a;@Autowiredpublic B(A a) {this.a = a;}
}

在这个例子中，通过使用构造器注入，我们可以在创建Bean实例时将依赖关系注入进去，避免了循环依赖问题。

2.使用setter注入：

setter注入是在Bean属性上使用setter方法注入依赖项的方式。这种方式通常会导致循环依赖问题，因为它是在实例化Bean后注入依赖项的。如果两个Bean都依赖于对方，并且都使用setter注入，就会形成一个循环依赖链。然而，在某些情况下，setter注入可能是必要的。此时，可以考虑将setter注入更改为构造器注入。

3.使用@Lazy注解：

@Lazy注解可以让Spring在需要时延迟加载Bean。当您使用@Lazy注解时，Spring会推迟初始化Bean，直到您首次使用该Bean时才创建它。这样可以让您避免循环依赖问题，因为Spring会按照依赖关系自动初始化Bean。例如：

java复制代码

@Service 
public class A { private final BService bService; @Autowired public A(@Lazy BService bService) { this.bService = bService; } 
}

在这个例子中，使用@Lazy注解可以避免循环依赖问题，因为Spring会延迟加载BService Bean。

4.使用@DependsOn注解：

@DependsOn注解可以让您指定一个或多个Bean的依赖关系。这样，Spring容器会先创建依赖的Bean，再创建被依赖的Bean，从而避免循环依赖的问题。例如：

java复制代码

@Service(dependsOn = "otherBean") public class MyBean { }

在这个例子中，MyBean将等待名为"otherBean"的Bean初始化完成后才进行初始化。这样可以避免循环依赖的问题。
5. 修改配置：如果以上方法仍然无法解决问题，可以尝试修改Spring Boot的配置。例如，将spring.main.dependency-check属性设置为true，这样可以自动检测循环依赖问题并报错。此外，还可以尝试使用代理模式来避免循环依赖的问题。例如，使用JDK动态代理或CGLIB代理来代理循环依赖的Bean。这样，当一个Bean依赖另一个Bean时，使用一个代理对象代替被依赖的Bean，这个代理对象在被依赖的Bean完全创建之前暂时代替被依赖的Bean。

6.三级缓存机制 

三级缓存是Spring框架中解决循环依赖问题的机制。它包括内存缓存、本地缓存和网络缓存三个级别。Spring Boot的三级缓存包含：singletonObjects、earlySingletonObjects和singletonFactories。

具体使用方法如下：

1. 在Spring容器中，当一个Bean需要注入另一个Bean时，Spring会先检查一级缓存（内存缓存）中是否已经存在该Bean的实例。如果存在，则直接注入；如果不存在，则继续检查二级缓存（本地缓存）和三级缓存（网络缓存）。
2. 如果在二级缓存中找到了该Bean的实例，则将其暴露给当前Bean，并放入一级缓存中。这个过程被称为“提前暴露”，可以解决循环依赖问题。
3. 如果在三级缓存中找到了该Bean的工厂对象，则通过工厂对象创建新的Bean实例，并将其放入二级缓存中。然后，将该Bean实例暴露给当前Bean，并放入一级缓存中。
4. 如果在三级缓存中没有找到工厂对象，则执行该Bean的实例化操作，并将其放入三级缓存中。然后，将该Bean实例暴露给当前Bean，并放入一级缓存中。
5. 通过以上步骤，可以确保每个Bean只会被创建一次，避免了循环依赖问题。同时，三级缓存的设计也确保了每个Bean只会被创建一次，从而避免了重复创建同一个Bean的问题。

四.解决循环依赖方法原理

1. 构造函数注入 构造函数注入是一种常见的解决循环依赖的方法。通过将依赖作为参数传递给构造函数，我们可以避免循环依赖的发生。这是因为构造函数注入是在对象创建时发生的，而不是在对象依赖被解析时发生的。这种方法的原理是通过将依赖作为参数传递给构造函数，使得对象的创建和依赖的解析分开进行。

2. Setter方法注入 Setter方法注入是另一种常用的解决循环依赖的方法。通过将依赖通过Setter方法注入到对象中，我们可以避免循环依赖的问题。这是因为Setter方法注入是在对象创建后发生的，而不是在对象依赖被解析时发生的。这种方法的原理是通过将依赖通过Setter方法注入到对象中，使得对象的创建和依赖的解析分开进行。

3. 使用@Lazy注解 @Lazy注解是Spring框架提供的一种解决循环依赖的方法。通过在Bean上添加@Lazy注解，我们可以延迟依赖的解析，从而避免循环依赖的发生。这是因为@Lazy注解告诉Spring在需要使用依赖时再进行解析，而不是在对象创建时就进行解析。这种方法的原理是通过延迟依赖的解析，使得对象的创建和依赖的解析分开进行。

4. 使用@DependsOn注解 @DependsOn注解是另一种解决循环依赖的方法。通过在Bean上添加@DependsOn注解，我们可以指定Bean的依赖顺序，从而避免循环依赖的问题。这是因为@DependsOn注解告诉Spring在创建Bean时先创建指定的依赖Bean，然后再创建当前Bean。这种方法的原理是通过指定依赖的创建顺序，使得对象的创建和依赖的解析分开进行。

5. 使用@PostConstruct注解 @PostConstruct注解是Spring框架提供的一种解决循环依赖的方法。通过在Bean的初始化方法上添加@PostConstruct注解，我们可以在Bean创建完成后执行一些初始化操作，从而避免循环依赖的问题。这是因为@PostConstruct注解告诉Spring在创建Bean后立即执行指定的初始化方法。这种方法的原理是通过在Bean创建完成后执行初始化方法，使得对象的创建和依赖的解析分开进行。

6. 在Spring框架中，三级缓存机制是通过使用注解来解决循环依赖问题的。具体来说，循环依赖问题主要发生在Bean的set赋值这个过程中。为了解决这个问题，Spring框架使用了@Autowired注解来依赖注入Bean。

   @Autowired注解可以解决循环依赖问题，因为它会自动地检查三级缓存中是否已经存在目标Bean的实例。如果存在，则直接注入；如果不存在，则等待该Bean被创建后再进行注入。这样，可以确保每个Bean只会被创建一次，避免了循环依赖问题。

   此外，三级缓存机制还解决了AOP代理的问题。在Spring框架中，通过AOP的加工，所有bean都会加工成对应的代理类bean。这时三级缓存就是为了解决AOP的问题存在的。在创建代理对象时，AOP会在初始化bean之后，在其后置处理器里创建代理对象。三级缓存解决了半成品bean不是代理类bean的问题，使得AOP可以正常工作。

   总之，三级缓存机制和@Autowired注解都是Spring框架中解决循环依赖问题的机制。通过结合使用它们，可以更好地解决循环依赖问题，并确保每个Bean只会被创建一次。

需要注意的是，虽然三级缓存可以解决循环依赖问题，但是在某些情况下可能会导致内存泄漏的问题。因此，在使用三级缓存时需要注意及时清理不再需要的Bean实例。

 虽然在架构设计过程中，我们会无意中造成循环依赖的场景，当真正发生相应的问题的时候，我们可以通过步骤二来判断是否真的发生了循环依赖的问题，如果真的是发生了循环依赖问题，那么我们需要根据具体情况分析，看哪一种方式解决问题更加合适，方便。然后结合原理来选择一种合适的解决方案。架构是一门艺术，其中的美用心体会，愿每一个问题的解决，都能给我们带来成就感的同时，也能够解决现实的问题，也成就我们的梦想