引言:循环依赖就是N个类中循环嵌套引用,如果在日常开发中我们用new 对象的方式发生这种循环依赖的话程序会在运行时一直循环调用,直至内存溢出报错。下面说一下Spring是如果解决循环依赖的。
第一种:构造器参数循环依赖
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;
- }
- }
OK,上面是很基本的3个类,,StudentA有参构造是StudentB。StudentB的有参构造是StudentC,StudentC的有参构造是StudentA ,这样就产生了一个循环依赖的情况,
我们都把这三个Bean交给Spring管理,并用有参构造实例化
- <bean id="a" class="com.zfx.student.StudentA">
- <constructor-arg index="0" ref="b"></constructor-arg>
- </bean>
- <bean id="b" class="com.zfx.student.StudentB">
- <constructor-arg index="0" ref="c"></constructor-arg>
- </bean>
- <bean id="c" class="com.zfx.student.StudentC">
- <constructor-arg index="0" ref="a"></constructor-arg>
- </bean>
下面是测试类:
- public class Test {
- public static void main(String[] args) {
- ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/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,StudentA依赖StudentB,然后将A放在“当前创建Bean池”中,此时创建StudentB,StudentB依赖StudentC ,然后将B放在“当前创建Bean池”中,此时创建StudentC,StudentC又依赖StudentA, 但是,此时Student已经在池中,所以会报错,,因为在池中的Bean都是未初始化完的,所以会依赖错误 ,(初始化完的Bean会从池中移除)
第二种:setter方式单例,默认方式
如果要说setter方式注入的话,我们最好先看一张Spring中Bean实例化的图
如图中前两步骤得知:Spring是先将Bean对象实例化之后再设置对象属性的
修改配置文件为set方式注入
- <!--scope="singleton"(默认就是单例方式) -->
- <bean id="a" class="com.zfx.student.StudentA" scope="singleton">
- <property name="studentB" ref="b"></property>
- </bean>
- <bean id="b" class="com.zfx.student.StudentB" scope="singleton">
- <property name="studentC" ref="c"></property>
- </bean>
- <bean id="c" class="com.zfx.student.StudentC" scope="singleton">
- <property name="studentA" ref="a"></property>
- </bean>
下面是测试类:
- public class Test {
- public static void main(String[] args) {
- ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
- System.out.println(context.getBean("a", StudentA.class));
- }
- }
打印结果为:
- com.zfx.student.StudentA@1fbfd6
为什么用set方式就不报错了呢 ?
我们结合上面那张图看,Spring先是用构造实例化Bean对象 ,此时Spring会将这个实例化结束的对象放到一个Map中,并且Spring提供了获取这个未设置属性的实例化对象引用的方法。 结合我们的实例来看,,当Spring实例化了StudentA、StudentB、StudentC后,紧接着会去设置对象的属性,此时StudentA依赖StudentB,就会去Map中取出存在里面的单例StudentB对象,以此类推,不会出来循环的问题喽、
下面是Spring源码中的实现方法,。以下的源码在Spring的Bean包中的DefaultSingletonBeanRegistry.java类中
- /** Cache of singleton objects: bean name --> bean instance(缓存单例实例化对象的Map集合) */
- private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);
- /** Cache of singleton factories: bean name --> ObjectFactory(单例的工厂Bean缓存集合) */
- private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16);
- /** Cache of early singleton objects: bean name --> bean instance(早期的单身对象缓存集合) */
- private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
- /** Set of registered singletons, containing the bean names in registration order(单例的实例化对象名称集合) */
- private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);
- /**
- * 添加单例实例
- * 解决循环引用的问题
- * Add the given singleton factory for building the specified singleton
- * if necessary.
- * <p>To be called for eager registration of singletons, e.g. to be able to
- * resolve circular references.
- * @param beanName the name of the bean
- * @param singletonFactory the factory for the singleton object
- */
- protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
- Assert.notNull(singletonFactory, "Singleton factory must not be null");
- synchronized (this.singletonObjects) {
- if (!this.singletonObjects.containsKey(beanName)) {
- this.singletonFactories.put(beanName, singletonFactory);
- this.earlySingletonObjects.remove(beanName);
- this.registeredSingletons.add(beanName);
- }
- }
- }
第三种:setter方式原型,prototype
修改配置文件为:
- <bean id="a" class="com.zfx.student.StudentA" <span style="color:#FF0000;">scope="prototype"</span>>
- <property name="studentB" ref="b"></property>
- </bean>
- <bean id="b" class="com.zfx.student.StudentB" <span style="color:#FF0000;">scope="prototype"</span>>
- <property name="studentC" ref="c"></property>
- </bean>
- <bean id="c" class="com.zfx.student.StudentC" <span style="color:#FF0000;">scope="prototype"</span>>
- <property name="studentA" ref="a"></property>
- </bean>
scope="prototype" 意思是 每次请求都会创建一个实例对象。两者的区别是:有状态的bean都使用Prototype作用域,无状态的一般都使用singleton单例作用域。
测试用例:
- public class Test {
- public static void main(String[] args) {
- ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
- <strong>//此时必须要获取Spring管理的实例,因为现在scope="prototype" 只有请求获取的时候才会实例化对象</strong>
- 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?
为什么原型模式就报错了呢 ?
对于“prototype”作用域Bean,Spring容器无法完成依赖注入,因为“prototype”作用域的Bean,Spring容
器不进行缓存,因此无法提前暴露一个创建中的Bean。
相关推荐
Spring循环依赖debug源码图
Spring循环依赖.vsdx
主要介绍了简单了解Spring循环依赖解决过程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
本篇文章主要介绍了Spring循环依赖的三种方式,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
循坏依赖即循环引用,两个或多个bean相互引用,最终形成一个环。这篇文章主要介绍了Spring循环依赖的解决办法,需要的朋友可以参考下
在开发中,可能经常出现这种情况,只是我们平时并没有注意到原来我们写的两个类、甚至多个类相互依赖了,为什么注意不到呢?...这一切都是Spring的功劳,它在后面默默的为我们解决了循环依赖的问题。
在开发中,可能经常出现这种情况,只是我们平时并没有注意到原来我们写的两个类、甚至多个类相互依赖了,为什么注意不到呢?...这一切都是Spring的功劳,它在后面默默的为我们解决了循环依赖的问题。
主要介绍了详解Spring循环依赖的解决方案,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
主要为大家详细介绍了spring循环依赖策略,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
《spring源码之循环依赖和三级缓存》整理,本人水平有限,从网上找的资料整合之后做的,请辩证的看待其中内容。
Spring源码最难问题:当Spring AOP遇上循环依赖.docx
想彻底弄清楚spring的循环依赖问题,首先得弄清楚 循环依赖是如何发生的,spring又是如何检测循环依赖的发生的。 其次再探究spring如何解决循环依赖的问题 最后我们将总结循环依赖解决的2个关键因素,提前曝光和曝光...
spring bean循环依赖时序图详细的描述了spring的循环依赖关系,帮我们快速了解spring是如何优雅的进行处理的
本篇文章主要介绍了浅谈Spring循环依赖的三种方式,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
主要给大家介绍了关于Spring循环依赖的正确性,以及Bean注入的顺序关系的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
Spring三级缓存解决循环依赖.pdf
主要介绍了浅谈Spring如何解决循环依赖的问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
Spring框架作为Java企业级应用的核心,其解决循环依赖的能力是其健壮性和灵活性的关键体现。循环依赖,即两个或多个组件相互依赖,常在大型应用中遇见。Spring通过三级缓存和AOP代理机制巧妙处理这一挑战。首先,一...
第一种:构造器参数循环依赖 Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中,Bean标识符在创建过程中将一直保持在这个池中。 因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”...
文章目录准备工作关闭循环依赖开始调试AbstractBeanFactory#doGetBeangetSingleton(String beanName, ...Spring默认在单例、非构造方法注入的情况下是支持循环依赖的。 准备工作 原创文章 94获赞 13访问量 5539