spring解决循环依赖
概述
循环依赖就是依赖关系形成环,比如最简单的循环依赖:a对象依赖b,b对象依赖a
属性注入与循环依赖
- 如果是构造器注入,如果循环依赖对象没法构建,因为还未实例化
- 如果是属性注入但是作用域是prototype,spring不会缓存其对象实例,也不能处理循环依赖的情况
- 如果是属性注入singleton的,其bean的实例化过程与属性注入过程是分开的,并且spring提供了三个map(就是大家说三级缓存)来实现。
spring属性注入处理循环依赖的方式
通过以下xml方式配置一个循环依赖的示例:
<bean id="person1" class="com.example.leetcode.spring.bean.person"> <property name="parent" ref="person2"></property> <property name="name" value="tom"></property> </bean> <bean id="person2" class="com.example.leetcode.spring.bean.person"> <property name="parent" ref="person1"></property> <property name="name" value="jack"></property> </bean>
spring循环依赖处理几个关键位置:
获取bean对象
protected <t> t dogetbean(final string name, @nullable final class<t> requiredtype, @nullable final object[] args, boolean typecheckonly) throws beansexception { final string beanname = transformedbeanname(name); object bean; // 这里会检查单例bean是否已经在注册表,并返回。 // eagerly check singleton cache for manually registered singletons. object sharedinstance = getsingleton(beanname); if (sharedinstance != null && args == null) { if (logger.istraceenabled()) { if (issingletoncurrentlyincreation(beanname)) { logger.trace("returning eagerly cached instance of singleton bean '" + beanname + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("returning cached instance of singleton bean '" + beanname + "'"); } } bean = getobjectforbeaninstance(sharedinstance, name, beanname, null); } ... }
defaultsingletonbeanregistry(单例对象注册表)的几个关键属性。
// 用来存储已经创建好的单例对象 /** cache of singleton objects: bean name to bean instance. */ private final map<string, object> singletonobjects = new concurrenthashmap<>(256); // 用来存储单例beanname到objectfactory的映射 /** cache of singleton factories: bean name to objectfactory. */ private final map<string, objectfactory<?>> singletonfactories = new hashmap<>(16); // 用来提前存储还未初始化好的单例对象 /** cache of early singleton objects: bean name to bean instance. */ private final map<string, object> earlysingletonobjects = new hashmap<>(16);
defaultsingletonbeanregistry.getsingleton()的实现.
protected object getsingleton(string beanname, boolean allowearlyreference) { object singletonobject = this.singletonobjects.get(beanname); if (singletonobject == null && issingletoncurrentlyincreation(beanname)) { synchronized (this.singletonobjects) { singletonobject = this.earlysingletonobjects.get(beanname); if (singletonobject == null && allowearlyreference) { objectfactory<?> singletonfactory = this.singletonfactories.get(beanname); if (singletonfactory != null) { singletonobject = singletonfactory.getobject(); this.earlysingletonobjects.put(beanname, singletonobject); this.singletonfactories.remove(beanname); } } } } return singletonobject; }
abstractautowirecapablebeanfactory.docreatebean创建对象与注入属性
protected object docreatebean(final string beanname, final rootbeandefinition mbd, final @nullable object[] args) throws beancreationexception { ... instancewrapper = createbeaninstance(beanname, mbd, args); ... // 检查是否提前将单例bean存入缓存 boolean earlysingletonexposure = (mbd.issingleton() && this.allowcircularreferences && issingletoncurrentlyincreation(beanname)); if (earlysingletonexposure) { if (logger.istraceenabled()) { logger.trace("eagerly caching bean '" + beanname + "' to allow for resolving potential circular references"); } // 这里将beanname与工厂映射放入缓存注册表中(也就是上面的singletonfactories) addsingletonfactory(beanname, () -> getearlybeanreference(beanname, mbd, bean)); } ... // 注入依赖属性 populatebean(beanname, mbd, instancewrapper); ... }
假设我们从beanfactory获取person1对象, 循环依赖处理流程如下:
1.通过abstractbeanfactory.dogetbean("persion1")获取对象
2.因为一开始通过defaultsingletonbeanregistry.getsingleton()什么都没有,进入abstractautowirecapablebeanfactory.docreatebean()进行创建
3.autowirecapablebeanfactory.docreatebean()里面执行完创建逻辑,因为是singleton将beanname与工厂的映射加入到addsingletonfactory()到缓存
4.开始处理person1对象的属性依赖populatebean()
5.当发现person1的parent属性是一个引用时,通过beanfactory.getbean("person2")获取依赖对象(org.springframework.beans.factory.support.beandefinitionvalueresolver#resolvereference)
6.此时进入person2的创建流程, person2也没有缓存,开始实例化并加入到addsingletonfactory()到缓存
7.person2在通过populatebean()注入属性依赖发现依赖person1, 此时通过beanfactory.getbean("person1")获取依赖对象
8.此时abstractbeanfactory.dogetbean("persion1")获取对象执行到getsingleton("person1")进行以下判断:
- 从singletonobjects.get(beanname)获取到null
- 进入if条件,对singletonobjects同步
- 从earlysingletonobjects.get(beanname);获取也为null
- 进入内层if,通过singletonfactories.get(beanname);获取到最开始bean实例化之后的beanname与工厂缓存信息
- 获取到仅实例化完成的bean,并earlysingletonobjects.put(beanname, singletonobject);
- 然后删除singletonfactories.remove(beanname);
9.此时从getsingleton("person1")返回了一个仅实例化尚未注入的bean引用
10.person2在第7步获取到person1仅实例化未注入的对象引用。
11.person2完成属性注入并返回。
12.person2被addsingleton(beanname, singletonobject);中singletonobjects.put(beanname, singletonobject)缓存,并删除singletonfactories.remove(beanname);earlysingletonobjects.remove(beanname);
13.person1在5步获取到person2的对象并完成属性注入
14.person1对象返回(因为一开始person2获取的是person1的引用,此时person1完成注入是能看到注入后的对象)
15.person1被addsingleton(beanname, singletonobject);中singletonobjects.put(beanname, singletonobject)缓存,并删除singletonfactories.remove(beanname);earlysingletonobjects.remove(beanname);
16.返回最终的person1对象
关于三个map(三级缓存)
在出现循环依赖时,三个map之间的流程如下:
先从singletonfactories获取工厂,并通过getobject获取对象并移除缓存,将对象缓存到earlysingletonobjects
通过earlysingletonobjects获取提前曝光的对象
对象创建并初始化完成之后,对象信息保留在singletonobjects并移除过earlysingletonobjects中的缓存
earlysingletonobjects二级缓存是鸡肋吗?
earlysingletonobjects缓存的目的是,通过三级缓存在获取对象会执行一些列的后置处理器,通过earlysingletonobjects来缓存提升性能。
以上就是spring解决循环依赖的详细内容,更多关于sping 循环依赖的资料请关注其它相关文章!
上一篇: 家用路由器要不要开启ipv6? ipv6的作用介绍
下一篇: 你两有仇
推荐阅读
-
Spring配置shiro时自定义Realm中属性无法使用注解注入的解决办法
-
js中for循环内的匿名函数使用i的问题及解决方案
-
Spring Cloud出现Options Forbidden 403问题解决方法
-
Spring框架、依赖注入、控制反转详解及代码说明
-
Spring bean的实例化和IOC依赖注入详解
-
Spring+SpringMVC配置事务管理无效原因及解决办法详解
-
spring boot 打包jar jar没有主目录清单问题的完美解决方法
-
Spring-boot JMS 发送消息慢的解决方法
-
spring cloud consul注册的服务报错critical的解决
-
浅谈Spring解决jar包依赖的bom