一、 解决Spring循环依赖问题
1.1 什么是循环依赖？
循环依赖就是循环引用，指两个或多个bean互相持有对方，比如说TestA引用TestB、TestB引用TestA，最终形成一个闭环。
注意：循环依赖不是指循环调用。
循环调用：指方法之间的环调用，循环调用是无解的，除非有终结条件，否则就是死循环，最终会导致内存溢出异常。
1.2 两种Spring容器循环依赖：
- 构造器循环依赖
- setter方法循环依赖
就是A类里面有B类的引用b，B类里面有C类的引用c，C类里面有A类的引用a，如下图所示
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函数，报错截图
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"); } }
最后输出
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 ..."); } }
最后输出
总结：
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模式。
