Java 解决service循环依赖 spring解决循环依赖问题

转载

mob64ca13fa6a3c 2023-10-10 22:53:16

文章标签 Java 解决service循环依赖 java spring bean ioc 文章分类 Java 后端开发

所有代码都在 https://gitee.com/zyxscuec/spring

文章目录

一、解决Spring循环依赖问题

1.1 什么是循环依赖？
1.2 两种Spring容器循环依赖：
1.3 在Spring中循环依赖处理分为3种情况

1.3.1　构造器循环依赖（无法解决）
1.3.2 setter循环依赖（可以解决）
1.3.3 范围的依赖处理

1.4 针对上述的作用域（scope）分析
1.5 spring容器提供了几种scope类型？

一、解决Spring循环依赖问题

1.1 什么是循环依赖？

循环依赖就是循环引用，指两个或多个bean互相持有对方，比如说TestA引用TestB、TestB引用TestA，最终形成一个闭环。

注意：循环依赖不是指循环调用。

循环调用：指方法之间的环调用，循环调用是无解的，除非有终结条件，否则就是死循环，最终会导致内存溢出异常。

1.2 两种Spring容器循环依赖：

构造器循环依赖
setter方法循环依赖

就是A类里面有B类的引用b，B类里面有C类的引用c，C类里面有A类的引用a，如下图所示

Java 解决service循环依赖 spring解决循环依赖问题_java

1.3 在Spring中循环依赖处理分为3种情况

1.3.1　构造器循环依赖（无法解决）

当循环依赖是通过构造器注入的时候，无论这些bean是singleton还是prototype都会报错，无法解决

表示通过构造器注入构成的循环依赖，此依赖是无解的，强行依赖只能抛出异（BeanCreationException）；

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

下列代码示例：

A类

package com.zhou.spring.testconstructor;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class A {
    private B b;

    public A (B b){
        this.b = b;
    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }
}

B类

package com.zhou.spring.testconstructor;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class B {
    private C c;

    public B (C c){
        this.c = c;
    }

    public C getC() {
        return c;
    }

    public void setC(C c) {
        this.c = c;
    }
}

C类

package com.zhou.spring.testconstructor;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class C {
    private A a;

    public C (A a){
        this.a = a;
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}

主函数入口

package com.zhou.spring.testconstructor;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author zhouyanxiang
 * @create 2020-09-2020/9/24-11:55
 */
public class SpringTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext3.xml");
    }

}

applicationContext3.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    					http://www.springframework.org/schema/beans/spring-beans.xsd
    					http://www.springframework.org/schema/mvc
    					http://www.springframework.org/schema/mvc/spring-mvc.xsd
    					http://www.springframework.org/schema/context
    					http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="A" class="com.zhou.spring.testconstructor.A" >
        <property name="b" ref="B"/>
    </bean>

    <bean id="B" class="com.zhou.spring.testconstructor.B" >
        <property name="c" ref="C"/>
    </bean>

    <bean id="C" class="com.zhou.spring.testconstructor.C" >
        <property name="a"  ref="A"/>
    </bean>
</beans>

运行main函数，报错截图

Java 解决service循环依赖 spring解决循环依赖问题_java_02

1.3.2 setter循环依赖（可以解决）

指通过setter注入方式构成的循环依赖。

解决方式：Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的bean来完成的。而且只能解决单例作用域的bean循环依赖。通过提前暴露一个单例工厂方法，从而使其他bean能引用到该bean。

首先需要去掉构造器注入的参数。就是构造方法中去掉构造参数

A.java

package com.zhou.spring.testsetter;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class A {
    private B b;

    public A (){

    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }
}

B.java

package com.zhou.spring.testsetter;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class B {
    private C c;

    public B (){

    }

    public C getC() {
        return c;
    }

    public void setC(C c) {
        this.c = c;
    }
}

C.java

package com.zhou.spring.testsetter;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class C {
    private A a;

    public C (){

    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}

测试类

package com.zhou.spring.testsetter;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author zhouyanxiang
 * @create 2020-09-2020/9/24-12:17
 */
public class SpringTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext4.xml");
        System.out.println("test success");
    }
}

最后输出

Java 解决service循环依赖 spring解决循环依赖问题_java_03

1.3.3 范围的依赖处理

1、对于prototype作用域bean，spring容器无法完成依赖注入，因为spring容器不进行缓存prototype作用域的bean，因此无法提前暴露一个正在创建中的bean。prototype即原型模式，调用多少次bean，就实例化多少次。

2、如果同时有prototype和singleton存在的时候，那么率先获取的bean的作用域是singleton的话，那也是可以通过的。

A.java

package com.zhou.spring.testrange;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class A {
    private B b;

    public A (){

    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }
}

B.java

package com.zhou.spring.testrange;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class B {
    private C c;

    public B (){

    }

    public C getC() {
        return c;
    }

    public void setC(C c) {
        this.c = c;
    }
}

C.java

package com.zhou.spring.testrange;

/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/13-18:01
 */
public class C {
    private A a;

    public C (){

    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}

测试类

package com.zhou.spring.testrange;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author zhouyanxiang
 * @create 2020-09-2020/9/24-12:17
 */
public class SpringTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext5.xml");
        System.out.println(" success ...");
    }
}

最后输出

Java 解决service循环依赖 spring解决循环依赖问题_ioc_04

总结：

Java 解决service循环依赖 spring解决循环依赖问题_java_05

1.4 针对上述的作用域（scope）分析

beanFactory除了拥有ioc的职责外，还有着对象生命周期管理。

scope用来声明容器中对象所应该处的限定场景或者该对象的存活时间，即容器在对象进入其相应的scope之前，生成并装配这些对象，在对象不再处于scope的限定之后，容器通常会销毁这些对象。

1.5 spring容器提供了几种scope类型？

singleton：在spring容器中只存在一个实例，所有对象的引用将共享这个实例。（注：不要和单例模式搞混）
prototype：容器每次都会生成一个新的对象实例给请求方。
request （限定在web应用中使用）：为每个http请求创建一个全新的request-processor对象供当前请求使用，请求结束，实例生命周期即结束。
session （限定在web应用中使用）：为每个独立的session创建一个全新的UserPreference对象实例。
global session （限定在web应用中使用）：只有应用在基于portlet的Web应用程序中才有意义，它映射到portlet的global范围的**session。**如果在普通的基于servlet的Web应用中使用了这个类型的scope，容器会将其作为普通的session类型的scope对待。

（1）singleton在容器中，只被实例化一次，而prototype在容器中，调用几次，就被实例化几次；

（2）在AppplicationContext容器中，singleton在applicaitonContext.xml加载时就被预先实例化，而prototype必须在调用时才实例化。也正是因为这样，预先被实例化了，所以在循环引用的时候，如果第一个bean的作用域是singleton的时候，可以正常的解决循环引用的问题。

（3）singleton比prototype消耗性能，在web开发中，推荐使用singleton模式，在app开发中，推荐使用prototype模式。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。