Spring如何解决循环依赖

最新推荐文章于 2024-10-10 11:29:57 发布

-SystemCaller-

最新推荐文章于 2024-10-10 11:29:57 发布

阅读量336

点赞数 1

分类专栏： Spring 文章标签：循环依赖

本文链接：https://blog.csdn.net/CSDN_zuoyueer/article/details/103312503

版权

Spring 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

对自己说的话

深入spring原理对现在的自己来说确定太难了,但是要坚持,点滴的积累,一定会有收获的~加油!

什么是循环依赖

所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。或者是 A 依赖 B，B 依赖 C，C 又依赖 A。它们之间的依赖关系如下：
在这里插入图片描述
根据创建对象的方式不同, 分为三种情况:

第一种：构造器参数循环依赖
第二种：setter方式单例，默认方式
第三种：setter方式原型，prototype,也就是多例

第一种：构造器参数循环依赖

Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持
在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出
BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

首先我们先初始化三个Bean。

public class StudentA {
 
    private StudentB studentB ;
 
    public void setStudentB(StudentB studentB) {
        this.studentB = studentB;
    }
 
    public StudentA() {
    }
    
    public StudentA(StudentB studentB) {
        this.studentB = studentB;
    }
}

public class StudentB {
 
    private StudentC studentC ;
 
    public void setStudentC(StudentC studentC) {
        this.studentC = studentC;
    }
    
    public StudentB() {
    }
 
    public StudentB(StudentC studentC) {
        this.studentC = studentC;
    }
}

public class StudentC {
 
    private StudentA studentA ;
 
    public void setStudentA(StudentA studentA) {
        this.studentA = studentA;
    }
 
    public StudentC() {
    }
 
    public StudentC(StudentA studentA) {
        this.studentA = studentA;
    }
}

上面是很基本的3个类，，StudentA有参构造是StudentB。StudentB的有参构造是StudentC，StudentC的有参构造是StudentA ，这样就产生了一个循环依赖的情况，
我们都把这三个Bean交给Spring管理，并用有参构造实例化对象到容器中

 	<bean id="a" class="com.zuoyueer.StudentA">
		<constructor-arg index="0" ref="b"></constructor-arg>
	</bean>
	<bean id="b" class="com.zuoyueer.StudentB">
		<constructor-arg index="0" ref="c"></constructor-arg>
	</bean>
	<bean id="c" class="com.zuoyueer.StudentC">
		<constructor-arg index="0" ref="a"></constructor-arg>
	</bean>

下面的测试类:

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/zuoyueer/applicationContext.xml");
        System.out.println(context.getBean("a", StudentA.class));
    }
}

执行结果报错信息为：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
	Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

分析原因:

Spring容器创建"StudentA " bean,首先去"当前创建bean池"查找是否当前bean正在创建，如果没有发现，则继续准备其需要的构造器参数"StudentB",并将"StudentA “标识符放置到"当前创建bean池”.
Spring容器创建"StudentB" bean,首先去"当前创建bean池"查找是否当前bean正在创建，如果没有发现，则继续准备其需要的构造器参数"StudentC",并将"StudentB"标识符放置到"当前创建bean池".
Spring容器创建"StudentC" bean,首先去"当前创建bean池"查找是否当前bean正在创建，如果没有发现，则继续准备其需要的构造器参数"StudentA “,并将"StudentC"标识符放置到"当前创建bean池”.
到此为止Spring容器要再次去创建"StudentA " bean，发现该bean标识符在"当前创建bean池"中，因为表示循环依赖，故抛出BeanCurrentlyInCreationExpection异常。因为在池中的Bean都是未初始化完的，所以会依赖错误，（初始化完的Bean会从池中移除）

第二种：setter方式单例，默认方式

修改配置文件为set方式注入,scope="singleton"表示单例,默认就是单例,可以不设置

	<!--scope="singleton"(默认就是单例方式)  -->
	<bean id="a" class="com.zuoyueer.StudentA" scope="singleton">
		<property name="studentB" ref="b"></property>
	</bean>
	<bean id="b" class="com.zuoyueer.StudentB" scope="singleton">
		<property name="studentC" ref="c"></property>
	</bean>
	<bean id="c" class="com.zuoyueer.StudentC" scope="singleton">
		<property name="studentA" ref="a"></property>
	</bean>

下面是测试类：

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/zuoyueer/applicationContext.xml");
        System.out.println(context.getBean("a", StudentA.class));
    }
}

打印结果为：(正常的创建了对象,没有异常)

com.zuoyueer.StudentA@F646AE

分析原因:

容器安装配置顺序,先去实例化"StudentA",首先会根据无参构造器创建一个bean,并储存该对象的引用储存到容器中, 这个引用是"StudentA对象的一个早期的引用（early reference）, 注意: 此时setter注入器还未被调用,这个对象是没有给属性赋值的.
再去实例化"StudentB",也会根据无参构造器创建一个bean,并把对象的早期的引用（early reference）储存到容器中.
再去实例化"StudentC", 因为"StudentC"依赖于"“StudentA” , 这时容器中有"StudentA"的对象的一个早期的引用（early reference）,那么就调用setter注入器, 把"StudentA"对象的早期引用注入到"StudentC"对象中
以上过程是递归完成是,所以"StudentC"实例化之后,会接着调用"StudentB"对象的setter注入器,最后调用"StudentA"对象的setter注入器,完成对象中属性的赋值.也就是依赖注入,

为了理解这个早期的引用（early reference）,我们需要了解Spring的三级缓存

缓存	用途
singletonObjects	用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
earlySingletonObjects	存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
singletonFactories	存放 bean 工厂对象，用于解决循环依赖

实际上, 根据无参构造器创建一个bean,并将此类对应的ObjectFactory暴露出去，也就是注册到singletonFactories中, 从而使其他的bean能引用到该bean.当你依赖到了该Bean而单例缓存里面有没有该Bean的时候就会调用该工厂方法生产Bean,此时setter注入器还未被调用

为什么不把Bean直接暴露出去，而是暴露个Factory呢？因为有些Bean是需要被代理的.

以上过程最关键的一点是Spring是先将Bean对象实例化(无参构造)之后再设置对象属性的

关于3级缓存,推荐一个博主的博客:https://blog.csdn.net/f641385712/article/details/92801300

第三种：setter方式原型，prototype,也就是多例

修改配置文件为：```scope=“prototype”``表示多例,也就是每次请求的时候都创建一个新的对象

	<bean id="a" class="com.zuoyueer.StudentA" scope="prototype">
		<property name="studentB" ref="b"></property>
	</bean>
	<bean id="b" class="com.zuoyueer.StudentB" scope="prototype">
		<property name="studentC" ref="c"></property>
	</bean>
	<bean id="c" class="com.zuoyueer.StudentC" scope="prototype">
		<property name="studentA" ref="a"></property>
	</bean>

打印结果：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
	Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?