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

最新推荐文章于 2024-07-26 13:41:12 发布
最新推荐文章于 2024-07-26 13:41:12 发布
阅读量680 收藏 5
点赞数 11
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jc0803kevin/article/details/140461537
版权

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 Boot中解决循环依赖问题
fudaihb的博客
08-19 1511
在Spring Boot项目中，循环依赖是一个常见的困扰开发者的问题。循环依赖发生在两个或多个Bean相互依赖，形成一个闭环，导致Spring容器无法正确初始化这些Bean。本文将深入解析Spring Boot中循环依赖的成因，并探讨各种解决循环依赖的策略和最佳实践。 ## 目录
Spring循环依赖及解决方式
热门推荐
车晋强的专栏
04-20 5万+
1. 什么是循环依赖？2. 怎么检测是否存在循环依赖3. Spring怎么解决循环依赖4.基于构造器的循环依赖5.基于setter属性的循环依赖6.结束语1. 什么是循环依赖？循环依赖其实就是循环引用，也就是两个或者两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。如下图：注意，这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终...
Spring 循环依赖及解决方式
最新发布
maizixuetang的博客
07-26 830
1、getBean(A) 先去单例池获取，单例池不存在，二级缓存获取，二级缓存不存在且允许提前访问，三级缓存中取，此时返回为空，开始加载 A2、singletonsCurrentlyInCreation(A) 将 A 放入正在创建的 Map 中3、new A();实例化 A4、提前暴露 A，将 A 放入三级缓存，addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
Spring如何解决循环依赖的问题
09-07
主要介绍了Spring是如何解决循环依赖的问题，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Spring如何解决循环依赖？
zhanghuyi2022的博客
04-25 516
spring是怎么解决循环依赖的，一级、二级、三级缓存扮演什么角色？ 本次分享，包括 1.一个简单的单例Bean的实例化过程 2.存在依赖的单例Bean的实例化过程 3.存在循环依赖的单例Bean的实例化过程
Spring如何解决循环依赖
m0_46420244的博客
08-07 1万+
我们先来看看官方文档的说法：通俗来讲，就是A依赖B或者B依赖A，或者C依赖自己本身，或是三个以上，例如A依赖B，B依赖C，C又依赖A。
浅谈Spring解决循环依赖的三种方式
08-28
Spring框架提供了三种方式来解决循环依赖问题：构造器参数循环依赖、setter方法循环依赖和使用三级缓存解决循环依赖。 第一种：构造器参数循环依赖 构造器参数循环依赖是指通过构造器注入构成的循环依赖。这种依赖...
Spring 解决循环依赖的 3 种方式.docx
06-28
以下将详细介绍Spring解决循环依赖的三种方式： 1. 构造器参数循环依赖（Constructor-based circular dependency） 这是描述中提到的第一种方式。当Spring检测到构造器参数中的循环依赖时，它会使用“三级缓存”...
Spring中循环依赖的解决方法详析
08-25
在Spring中，属性循环依赖的解决方法主要包括三种策略：静态单例（Singleton），早期原型（Eager Prototype），和三级缓存（也就是所谓的三级联动）。 1. 静态单例：Spring默认采用的策略，只在BeanFactory初始化...
浅谈Spring如何解决循环依赖的问题
08-25
"浅谈Spring如何解决循环依赖的问题" Spring框架是如何解决循环依赖的问题？这是一个经常被问到的高频面试题。要理解这个问题，需要从源码的角度对其实现原理进行讲解。 首先，需要了解 Spring bean 的创建过程。...
spring 如何解决循环依赖
快乐的小三菊的博客
07-04 3799
spring 如何解决循环依赖
mysql循环依赖_spring：我是如何解决循环依赖的？
weixin_39641697的博客
02-02 459
它1.由同事抛的一个问题开始最近项目组的一个同事遇到了一个问题，问我的意见，一下子引起的我的兴趣，因为这个问题我也是第一次遇到。平时自认为对spring循环依赖问题还是比较了解的，直到遇到这个和后面的几个问题后，重新刷新了我的认识。我们先看看当时出问题的代码片段：@Servicepublic class TestService1{@Autowiredprivate TestService2 tes...
Spring如何解决循环依赖和循环依赖问题解决
刘皇叔说Java的博客
05-11 1268
要普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理时，就要使用代理对象覆盖掉之前的普通对象，在实际的调用过程中，是没有办法确定什么时候对象被使用，所以就要求当某个对象被调用的时候，优先判断此对象是否被代理，类似于一种回调机制的实现，因此传入lambda表达式的时候，可以通过lambda表达式来执行对象的覆盖过程，getEarlyBeanReference（）单例的Bean被创建后就被存放在一级缓存中，其实就是一个Map，只要这个单例bean被创建后，以后再次获取直接从Map中获取。
Spring 循环依赖解决方案
sinat_34814635的博客
11-24 1万+
循环依赖就是循环引用，就是两个或多个Bean相互之间的持有对方，比如A引用B，B引用C，C引用A，则它们最终反映为一个环。结论先行：1.构造器循环依赖----初始化失败2.field属性注入循环依赖----初始化成功3.field属性注入循环依赖（prototype）----初始化失败现象总结：同样对于循环依赖的场景，构造器注入和prototype类型的属性注入都会初始化Bean失败。因为@Service默认是单例的，所以单例的属性注入是可以成功的。
【Spring】Spring 解决循环依赖的 3 种方式
九师兄
09-09 9669
原文：http://www.javastack.cn/article/2020/spring-cycle-depends-on-three-ways/ 循环依赖就是N个类中循环嵌套引用，如果在日常开发中我们用new 对象的方式发生这种循环依赖的话程序会在运行时一直循环调用，直至内存溢出报错。 下面说一下Spring是如果解决循环依赖的。 第一种：构造器参数循环依赖 Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中。 因此如果
Spring中的循环依赖问题介绍及解决方法
wangxin1248的博客
06-05 5657
Spring容器能顺利的实例化以构造函数注入方式配置的bean有一个前提：即bean构造函数入参引用的对象必须已经准备就绪。 那么如果两个bean都采用构造函数注入，并且都通过构造函数入参引用了对方。就会发生类似与线程死锁的循环依赖问题。 那么接下来我们看一个发生循环依赖问题的例子： public class Car{ private String brand; privat
Spring框架解决循环依赖的三种策略解析
本文将详细讲解Spring解决循环依赖的三种方法。 1. **构造器参数循环依赖** Spring不支持通过构造器参数解决循环依赖，因为构造器注入时，Bean的创建过程会立即要求所有依赖的Bean也已准备好。例如，Bean A的构造...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

半山猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值