0
点赞
收藏
分享

微信扫一扫

Spring中的循环依赖

1. 什么是循环依赖

当一个bean A依赖于另一个bean B,并且bean B也依赖于bean A时,就会发生这种情况:

Bean A → Bean B → Bean A

当然,我们能有更多的beans依赖如下:

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(通过构造函数注入):

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public CircularDependencyA(CircularDependencyB circB) {
        this.circB = circB;
    }
}
@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
 
    @Autowired
    public CircularDependencyB(CircularDependencyA circA) {
        this.circA = circA;
    }
}

现在,我们可以为测试编写一个Configuration类,将其称为TestConfig,它指定要扫描组件的基本程序包。 假设我们的bean是在“ com.baeldung.circulardependency”包中定义的:

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

最后,我们可以编写一个JUnit测试来检查循环依赖。 该测试可以为空,因为在上下文加载期间将检测到循环依赖关系。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyTest {
 
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // Empty test; we just want the context to load
    }
}

If you try to run this test, you will get the following exception:

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更改为以下内容:

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}

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

4.3 使用 Setter/Field 注入

最受欢迎的解决方法之一,也是Spring文档提出的建议,就是使用setter注入。

简而言之,如果您更改了使用setter注入(或字段注入)而不是构造函数注入的方式连接bean的方式,那么确实可以解决该问题。 通过这种方式,Spring创建了bean,但是直到需要它们时才注入依赖项。

我们来做–让我们更改类以使用setter注入,并将另一个字段(消息)添加到CircularDependencyB中,以便我们进行适当的单元测试:

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public void setCircB(CircularDependencyB circB) {
        this.circB = circB;
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}
@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;
    }
}

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyTest {
 
    @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已被正确注入,并检查其消息属性的值。

4.4 使用 @PostConstruct

打破周期的另一种方法是在一个bean上使用@Autowired注入依赖项,然后使用带有@PostConstruct注释的方法设置另一个依赖项。

我们的bean可能具有以下代码:

@Component
public class CircularDependencyA {
 
    @Autowired
    private CircularDependencyB circB;
 
    @PostConstruct
    public void init() {
        circB.setCircA(this);
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}
@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 and InitializingBean

如果其中一个bean实现了ApplicationContextAware,则该bean可以访问Spring上下文,并且可以从那里提取另一个bean。 在实现InitializingBean时,我们指示该bean必须在其所有属性都已设置之后才能执行一些操作; 在这种情况下,我们要手动设置依赖关系。

我们的bean的代码为:

@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;
    }
}
@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,因此不需要循环依赖:它们通常是可以改进的设计的症状。

但是,如果您的项目中绝对需要循环依赖,则可以遵循此处建议的一些解决方法。

首选方法是使用二传手进样。 但是还有其他选择,通常基于阻止Spring管理Bean的初始化和注入,然后自己使用一种或多种策略来完成。

这些示例可以在GitHub项目中找到。

相关文章可看:Java详解之Spring Bean的循环依赖解决方案

举报

相关推荐

0 条评论