脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring循环依赖

Spring解决循环依赖问题的四种方法汇总

 更新时间：2024年07月21日 13:58:35   作者：jc0803kevin  
这篇文章主要介绍了Spring解决循环依赖问题的四种方法汇总,本文给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧

Spring解决循环依赖问题的四种方法

  • @Lazy方式
  • 使用Setter/Field Injection
  • 使用@PostConstruct
  • 实现 ApplicationContextAware 和 InitializingBean

不管使用那种方式，最佳的还是通过调整代码结构，从根上设计从而达到避免。

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

package icu.kevin.springpart.circular.constructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyA {
    private CircularDependencyB circB;
    @Autowired
    public CircularDependencyA(CircularDependencyB circB) {
        this.circB = circB;
    }
}
package icu.kevin.springpart.circular.constructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyB {
    private CircularDependencyA circA;
    @Autowired
    public CircularDependencyB(CircularDependencyA circA) {
        this.circA = circA;
    }
}
package icu.kevin.springpart.circular.constructor;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = { "icu.kevin.springpart.circular.constructor" })
public class TestConfig {
}

编写测试用例，测试是否存在循环依赖

package icu.kevin.springpart.circular.constructor;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {
    // Error creating bean with name 'circularDependencyA': Requested bean is currently in creation: Is there an unresolvable circular reference?
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // 测试可以为空，因为在上下文加载期间将检测到循环依赖关系
    }
}

@Lazy方式

@Lazy告诉 Spring 延迟初始化其中一个 bean。因此，它不会完全初始化 Bean，而是创建一个代理将其注入另一个 Bean。注入的 Bean 只有在第一次需要时才会完全创建。

@Lazy 注解是通过建立一个中间代理层，来破解循环依赖的。

package icu.kevin.springpart.circular.lazy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyA {
    private CircularDependencyB circB;
    @Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}
package icu.kevin.springpart.circular.lazy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyB {
    private CircularDependencyA circA;
    @Autowired
    public CircularDependencyB(CircularDependencyA circA) {
        this.circA = circA;
    }
}
package icu.kevin.springpart.circular.lazy;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = { "icu.kevin.springpart.circular.lazy" })
public class TestConfig {
}
package icu.kevin.springpart.circular.lazy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {
    // Error creating bean with name 'circularDependencyA': Requested bean is currently in creation: Is there an unresolvable circular reference?
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // 测试可以为空，因为在上下文加载期间将检测到循环依赖关系
    }
}

启动可以看出，在上下文检查循环依赖是可以正常通过的

查看源码ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary首先会调用 isLazy 去判断一下是否需要延迟加载，
如果需要，则调用 buildLazyResolutionProxy 方法构建一个延迟加载的对象；

使用Setter/Field Injection

在setter注入的时候发生的依赖循环是可以被解决的，但只能解决单例情况的循环依赖。
对于setter注入造成的依赖是通过Spring容器提前暴露刚刚完成构造器但还没有进行注入的bean来完成的。通过提前暴露一个单例工厂让其他的bean可以引用到该Bean。

package icu.kevin.springpart.circular.setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyA {
    private CircularDependencyB circB;
    public CircularDependencyB getCircB() {
        return circB;
    }
    @Autowired
    public void setCircB(CircularDependencyB circB) {
        this.circB = circB;
    }
}
package icu.kevin.springpart.circular.setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyB {
    private CircularDependencyA circA;
    private String message = "Hi!";
    public CircularDependencyA getCircA() {
        return circA;
    }
    @Autowired
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}
package icu.kevin.springpart.circular.setter;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = { "icu.kevin.springpart.circular.setter" })
public class TestConfig {
}
package icu.kevin.springpart.circular.setter;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {
    @Autowired
    private ApplicationContext context;
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // Empty test; we just want the context to load
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);
        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
    }
}

使用@PostConstruct

package icu.kevin.springpart.circular.postConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class CircularDependencyA {
    @Autowired
    private CircularDependencyB circB;
    @PostConstruct
    public void init(){
        circB.setCircA(this);
    }
    public CircularDependencyB getCircB() {
        return circB;
    }
}
package icu.kevin.springpart.circular.postConstruct;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyB {
    private CircularDependencyA circA;
    private String message = "Hi!";
    public CircularDependencyA getCircA() {
        return circA;
    }
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}
package icu.kevin.springpart.circular.postConstruct;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = { "icu.kevin.springpart.circular.postConstruct" })
public class TestConfig {
}
package icu.kevin.springpart.circular.postConstruct;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {
    @Autowired
    private ApplicationContext context;
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        //
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);
        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
    }
}

实现 ApplicationContextAware 和 InitializingBean

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

通过实现 InitializingBean，我们指示该 Bean 在设置完所有属性后必须执行一些操作。在这种情况下，我们要手动设置依赖项。

package icu.kevin.springpart.circular.initializingBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@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;
    }
}
package icu.kevin.springpart.circular.initializingBean;
import org.springframework.stereotype.Component;
@Component
public class CircularDependencyB {
    private CircularDependencyA circA;
    private String message = "Hi!";
    public CircularDependencyA getCircA() {
        return circA;
    }
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}
package icu.kevin.springpart.circular.initializingBean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = { "icu.kevin.springpart.circular.initializingBean" })
public class TestConfig {
}
package icu.kevin.springpart.circular.initializingBean;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyIntegrationTest {
    @Autowired
    private ApplicationContext context;
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // Empty test; we just want the context to load
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);
        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
    }
}

到此这篇关于Spring解决循环依赖问题的四种方法的文章就介绍到这了,更多相关Spring循环依赖内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 分模块构建Maven工程的方法步骤

    分模块构建Maven工程的方法步骤

    这篇文章主要介绍了分模块构建Maven工程的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-10-10
  • java进行远程部署与调试及原理详解

    java进行远程部署与调试及原理详解

    这篇文章主要介绍了java进行远程部署与调试及原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-12-12
  • Java实现添加,读取和删除Excel图片的方法详解

    Java实现添加,读取和删除Excel图片的方法详解

    本文介绍在Java程序中如何添加图片到excel表格，以及如何读取、删除excel表格中已有的图片。文中的示例代码讲解详细，感兴趣的可以学习一下
    2022-05-05
  • 解决springboot文件上传提示临时文件夹不存在问题

    解决springboot文件上传提示临时文件夹不存在问题

    这篇文章主要介绍了解决springboot文件上传提示临时文件夹不存在问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-05-05
  • Java中Iterator与ListIterator迭代的区别

    Java中Iterator与ListIterator迭代的区别

    本文主要介绍了Java中Iterator与ListIterator迭代的区别，文中通过示例代码介绍的非常详细，需要的朋友们下面随着小编来一起学习学习吧
    2021-07-07
  • SpringBoot 2.7.18 集成 Mybatis Plus + Druid的实例详解

    SpringBoot 2.7.18 集成 Mybatis Plus + Druid的实例详解

    Mybatis和MybatisPlus都是流行的持久层框架,MybatisPlus在Mybatis基础上增加了更多便捷的功能,如自动CRUD、分页插件等,文章还提到了Entity、Mapper、Service、Controller等组件的基本使用方法,为开发者提供了一套完整的集成方案
    2024-10-10
  • java中HashMap的七种遍历方式小结

    java中HashMap的七种遍历方式小结

    本文主要介绍了java中HashMap的七种遍历方式小结,包括迭代器,For Each,Lambda,Streams API等,具有一定的参考价值,感兴趣的可以了解一下
    2024-01-01
  • 关于使用jpa聚合函数遇到的问题

    关于使用jpa聚合函数遇到的问题

    这篇文章主要介绍了关于使用jpa聚合函数遇到的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-02-02
  • Springboot2集成pagehelper过程图解

    Springboot2集成pagehelper过程图解

    这篇文章主要介绍了springboot2集成pagehelper过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-03-03
  • 解决for循环为空不需要判断的问题

    解决for循环为空不需要判断的问题

    这篇文章主要介绍了解决for循环为空不需要判断的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09

最新评论