Spring 中的循环依赖

## 1.什么是循环依赖？

当一个 Bean A 依赖于另一个 Bean B，并且 Bean B 也依赖于 Bean A 时，就会发生循环依赖：

Bean A → Bean B → Bean A

当然，我们可以隐含更多的 bean：

Bean A → Bean B → Bean C → Bean D → Bean E → Bean A

## 2. Spring 中发生了什么

当 Spring 上下文加载所有 Bean 时，它会尝试按照它们完全工作所需的顺序创建 Bean。

假设我们没有循环依赖关系。相反，我们有这样的东西：

Bean A → Bean B → Bean C

Spring 将创建 Bean C，然后创建 Bean B（并将 Bean C 注入其中），然后创建 Bean A（并将 Bean B 注入其中）。

但是对于循环依赖，Spring 无法决定应该首先创建哪个 bean，因为它们相互依赖。在这些情况下，Spring 在加载上下文时将引发 BeanCurrentlyInCreationException。

在 Spring 中使用构造函数注入时可能会发生这种情况。如果我们使用其他类型的注入，则不会出现此问题，因为依赖项将在需要时注入，而不是在上下文加载时注入。

## 3. 一个简单的例子

让我们定义两个相互依赖的 bean（通过构造函数注入）：

```java
@Component
public class CircularDependencyA {

private CircularDependencyB circB;

@Autowired
    public CircularDependencyA(CircularDependencyB circB) {
        this.circB = circB;
    }
}
```

```java
@Component
public class CircularDependencyB {

private CircularDependencyA circA;

@Autowired
    public CircularDependencyB(CircularDependencyA circA) {
        this.circA = circA;
    }
}
```

现在我们可以为测试编写一个配置类（我们称之为 TestConfig），它指定要扫描组件的基础包。

假设我们的 bean 是在包“com.baeldung.circulardependency”中定义的：

```java
@Configuration
@ComponentScan(basePackages = { "com.baeldung.circulardependency" })
public class TestConfig {
}
```

最后，我们可以编写一个 JUnit 测试来检查循环依赖。

该测试可以为空，因为在上下文加载期间将检测到循环依赖：

```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {

@Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // Empty test; we just want the context to load
    }
}
```

如果我们尝试运行此测试，我们将得到此异常：

```java
BeanCurrentlyInCreationException: Error creating bean with name 'circularDependencyA':
Requested bean is currently in creation: Is there an unresolvable circular reference?
```

## 4. 解决方法

我们现在将展示一些最流行的方法来处理这个问题。

### 4.1.重新设计

当我们存在循环依赖时，很可能存在设计问题并且职责没有很好地分离。我们应该尝试正确地重新设计组件，以便它们的层次结构设计良好并且不需要循环依赖。

然而，有很多可能的原因我们可能无法进行重新设计，例如遗留代码、已经经过测试且无法修改的代码、没有足够的时间或资源进行完整的重新设计等等。重新设计组件，我们可以尝试一些解决方法。

### 4.2.使用 `@Lazy`

打破这个循环的一个简单方法是告诉 Spring 延迟初始化其中一个 bean。因此，它不会完全初始化 Bean，而是创建一个代理将其注入另一个 Bean。注入的 Bean 只有在第一次需要时才会完全创建。

为了在代码中尝试这样做，我们可以更改 CircularDependencyA：

```java
@Component
public class CircularDependencyA {

private CircularDependencyB circB;

@Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}
```

如果我们现在运行测试，我们将看到这次不会发生错误。

### 4.3. 使用 Setter/Field Injection

最流行的解决方法之一，也是 Spring 文档所建议的，是使用 setter 注入。

简单地说，我们可以通过改变 Bean 的接线方式来解决这个问题——使用 setter 注入（或字段注入）而不是构造函数注入。这样，Spring 会创建 bean，但依赖项在需要之前不会注入。

```java
@Component
public class CircularDependencyA {

private CircularDependencyB circB;

@Autowired
    public void setCircB(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }

public CircularDependencyB getCircB() {
        return circB;
    }
}
```

```java
@Component
public class CircularDependencyB {

private CircularDependencyA circA;

private String message = "Hi!";

@Autowired
    public void setCircA(@Lazy CircularDependencyA circA) {
        this.circA = circA;
    }

public String getMessage() {
        return message;
    }
}
```

现在我们必须对单元测试进行一些更改：

```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {

@Autowired
    ApplicationContext context;

@Bean
    public CircularDependencyA getCircularDependencyA() {
        return new CircularDependencyA();
    }

@Bean
    public CircularDependencyB getCircularDependencyB() {
        return new CircularDependencyB();
    }

@Test
    public void givenCircularDependency_whenSetterInjection_thenItWorks() {
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);

Assert.assertEquals("Hi!", circA.getCircB().getMessage());
    }
}
```

让我们仔细看看这些注解。

@Bean 告诉 Spring 框架必须使用这些方法来检索要注入的 Bean 的实现。使用 @Test 注释，测试将从上下文中获取 CircularDependencyA bean，并断言其 CircularDependencyB 已正确注入，检查其消息属性的值。

此外，我们将 @Lazy 注释与 setter 注入结合使用。通过使用 @Lazy 注释 setter 方法参数，我们指示 Spring 延迟初始化依赖的 bean。延迟初始化意味着 Spring 只会在需要时创建并注入 bean，而不是在启动时急切地初始化它。

这种方法有效地打破了循环依赖链，因为每个 bean 将在首次访问时进行初始化，从而防止任何初始化冲突。通过推迟标记有 @Lazy 的 bean 的初始化，我们确保 Spring 可以优雅地处理循环依赖，而不会遇到运行时问题。

### 4.4.使用 @PostConstruct

打破循环的另一种方法是在其中一个 bean 上使用 @Autowired 注入依赖项，然后使用用 @PostConstruct 注释的方法来设置另一个依赖项。

我们的 bean 代码如下：

```java
@Component
public class CircularDependencyA {

@Autowired
    private CircularDependencyB circB;

@PostConstruct
    public void init() {
        circB.setCircA(this);
    }

public CircularDependencyB getCircB() {
        return circB;
    }
}
```

```java
@Component
public class CircularDependencyB {

private CircularDependencyA circA;
	
    private String message = "Hi!";

public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
	
    public String getMessage() {
        return message;
    }
}
```

我们可以运行之前的相同测试，因此我们检查循环依赖异常是否仍然没有被抛出，并且依赖项是否被正确注入。

### 4.5.实现 ApplicationContextAware 和 InitializingBean

如果其中一个 bean 实现了 ApplicationContextAware，则该 bean 可以访问 Spring 上下文，并可以从那里提取另一个 bean。

通过实现 InitializingBean，我们表明该 bean 在设置其所有属性后必须执行一些操作。在这种情况下，我们想要手动设置我们的依赖关系。

这是我们的 Bean 的代码：

```java
@Component
public class CircularDependencyA implements ApplicationContextAware, InitializingBean {

private CircularDependencyB circB;

private ApplicationContext context;

public CircularDependencyB getCircB() {
        return circB;
    }

@Override
    public void afterPropertiesSet() throws Exception {
        circB = context.getBean(CircularDependencyB.class);
    }

@Override
    public void setApplicationContext(final ApplicationContext ctx) throws BeansException {
        context = ctx;
    }
}
```

```java
@Component
public class CircularDependencyB {

private CircularDependencyA circA;

private String message = "Hi!";

@Autowired
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }

public String getMessage() {
        return message;
    }
}
```

同样，我们可以运行之前的测试，并看到异常没有抛出，并且测试按预期工作。

## 5. 结论

Spring 中有很多处理循环依赖的方法。

我们应该首先考虑重新设计我们的 bean，这样就不需要循环依赖。这是因为循环依赖通常是可以改进的设计的症状。