什么是循环依赖
循环依赖就是循环引用,每个类中嵌套引用,在spring中表现为两个或多个bean相互之间持有对方,比如A引用B,B引用C,C又引用A,最终反映出来形成一个环。循环调用时无法解决的,一定要有终止条件才可以,否则就是死循环,最终的结果就是内存溢出。
spring中的循环依赖场景
- 构造器的循环依赖
- field属性的循环依赖
构造器循环依赖
通过构造器注入构成的循环依赖,此依赖是无法解决的,只能抛出BeanCurrentlyInCreationException
描述:创建A时,构造器需要B,那将去创建B,完了发现需要C,完了发现又需要A,从而形成一个环。
原理:Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中,bean标识符创建过程中将一直保持在这个池中,因为如果在创建bean过程中发现自己已经在“当前创建bean池”中时,将会抛出BeanCurrentlyInCreationException异常表示循环依赖;而对于创建完毕的bean将从“当前创建bean池”中清除掉。因为在池中的Bean都是未初始化完的,所以会依赖错误 ,(初始化完的Bean会从池中移除)
过程分析:(构造器依赖 A -> B -> C -> A):
- Spring容器创建A bean,首先去 “当前创建bean池”中查找是否当前bean正在创建(通过beanName),如果发现没有,则继续准备其需要的构造器参数B,并将A标识符放到“当前创建bean池”
- Spring容器创建B bean,Spring容器创建B bean,首先去 “当前创建bean池”中查找是否当前bean正在创建(通过beanName),如果发现没有,则继续准备其需要的构造器参数C,并将B标识符放到“当前创建bean池”
- Spring容器创建C bean,Spring容器创建C bean,首先去 “当前创建bean池”中查找是否当前bean正在创建(通过beanName),如果发现没有,则继续准备其需要的构造器参数A,并将C标识符放到“当前创建bean池”
- C的创建需要先创建A bean,此时发现A已经在“当前创建bean池”中,检测到了循环依赖,直接抛出BeanCurrentlyInCreationException异常
setter循环依赖
原理:对于setter注入造成的依赖是通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤(不如setter注入)的bean来完成的,而且只能解决单例作用域的bean循环依赖。
通过提前暴露一个单例工厂方法,从而使其他bean能引用到该bean的addSingletonFactory方法
看一看spring中bean实例化的图
可以看到Spring是先将bean对象实例化,之后再设置对象属性的,此时spring会将这个实例化结束的对象放到一个Map中,并且Spring提供了获取这个未设置属性的实例化对象引用的方法。
结合实例
<bean id="a" class="com.bean.test.TestA" scope="singleton">
<property name="testB" ref="b"></property>
</bean>
<bean id="b" class="com.bean.test.TestB" scope="singleton">
<property name="testC" ref="c"></property>
</bean>
<bean id="c" class="com.bean.test.TestC" scope="singleton">
<property name="testA" ref="a"></property>
</bean>
当spring实例化了TestA,TestB,TestC后,紧接着回去设置对象的属性,此时TestA依赖testB就会去Map中取出里面的单例TestB,等到TestC去取TestA时发现TestA时就会形成循环依赖
prototype范围的依赖处理
将之前的文件修改为
<bean id="a" class="com.bean.test.TestA" scope="prototype">
<property name="testB" ref="b"></property>
</bean>
<bean id="b" class="com.bean.test.TestB" scope="prototype">
<property name="testC" ref="c"></property>
</bean>
<bean id="c" class="com.bean.test.TestC" scope="prototype">
<property name="testA" ref="a"></property>
</bean>
执行抛出BeanCreateException异常。
对于Protype作用域的bean,spring无法完成依赖注入,因为prototype作用域的bean,spring容器不进行缓存,因此无法提前暴露一个创建中的bean
对于单例作用域的bean,可以通过setAllowCircularReferences(false)来禁用循环依赖,这样如果存在循环引用就会抛出异常来通知用户
spring解决循环依赖 三级缓存
这三级缓存分别指:
3. singletonObjects:单例对象的cache
2. earlySingletonObjects:提前曝光的单例对象的Cache
- singletonFactories:单例对象工厂的cache
/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
/** Cache of singleton factories: bean name --> ObjectFactory */
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);
第一级缓存singletonObjects里面放置的是实例化好的单例对象。
第二级缓存earlySingletonObjects里面存放的是提前曝光的单例对象(没有完全装配好)。
第三级缓存singletonFactories里面存放的是要被实例化的对象的对象工厂。
我们在创建bean的时候,首先是从cache中获取这个单例的bean,这个缓存就是singletonObjects
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 != NULL_OBJECT ? singletonObject : null);
}
- isSingletonCurrentlyInCreation()判断当前单例bean是否正在创建中,也就是没有初始化完成(比如A的构造区依赖了B对象,所以得先去创建B对象,这时A就处于创建中的状态)
- allowEarlyReference 是否允许从singletonFactories中通过getObject获取对象
分析getSingleton()的整个过程,Spring首先从一级缓存singletonObjects中获取。如果获取不到,并且对象正在创建中,就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取,就从三级缓存singletonFactory.getObject()(三级缓存)获取,如果获取到了则:
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
从singletonFactories中移除,并放入earlySingletonObjects中。其实也就是从三级缓存移动到了二级缓存。
从上面三级缓存的分析,我们可以知道,Spring解决循环依赖的诀窍就在于singletonFactories这个三级cache。这个cache的类型是ObjectFactory,定义如下:
public interface ObjectFactory<T> {
T getObject() throws BeansException;
}
这个接口在下面被引用
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);
}
}
}
这段代码发生在createBeanInstance之后,也就是说单例对象此时已经被创建出来(调用了构造器)。这个对象已经被生产出来了,虽然还不完美(还没有进行初始化的第二步和第三步),但是已经能被人认出来了(根据对象引用能定位到堆中的对象),所以Spring此时将这个对象提前曝光出来让大家认识,让大家使用。
//TODO
https://www.jianshu.com/p/16a44c25c9d9
参考
Spring容器的循环依赖检测
Spring循环依赖以及解决方式
Spring-bean的循环依赖以及解决方式
Spring循环依赖的解决方案