Spring源码解析-6、spring单例如何解决循环依赖

什么叫循环依赖

循环依赖即两个及以上的bean对象互相持有对方的引用,最终形成一个闭环。

spring如何处理正在创建的Bean

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

循环依赖的三种情况

构造器

public class BeanA {
    private BeanB b;

    public BeanA(BeanB b) {
        this.b = b;
    }
}

public class BeanB {
    private BeanC c;

    public BeanB(BeanC c) {
        this.c = c;
    }
}

public class BeanC {
    private BeanA a;

    public BeanC(BeanA a) {
        this.a = a;
    }
}

----------------------
 
        
    
    
        
    
    
        
    
----------------------
   ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

报错:
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容器先创建单例BeanA,BeanA依赖BeanB,然后将A放在“当前创建Bean池”中,此时创建BeanB,BeanB依赖BeanC ,然后将B放在“当前创建Bean池”中,此时创建BeanC,StudentC又依赖BeanA, 但是,此时BeanA已经在池中,所以会报错,,因为在池中的Bean都是未初始化完的,所以会依赖错误 ,(初始化完的Bean会从池中移除)

单例setter

public class BeanA {
    public BeanB b;

    public void setB(BeanB b) {
        this.b = b;
    }
}
public class BeanB {
    public BeanC c;

    public void setC(BeanC c) {
        this.c = c;
    }
}
public class BeanC {
    public BeanA a;

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

        
    
    
        
    
    
        
    
----------------------
 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        BeanA a = context.getBean("a", BeanA.class);
        BeanB b = context.getBean("b", BeanB.class);
        BeanC c = context.getBean("c", BeanC.class);
        System.out.println(String.format("a:%s,a.b:%s",a,a.b));
        System.out.println(String.format("b:%s,b.c:%s",b,b.c));
        System.out.println(String.format("c:%s,c.a:%s",c,c.a));

输出:
a:com.raycloud.dmj.data.utils.BeanA@46bfc63c,a.b:com.raycloud.dmj.data.utils.BeanB@586fb16d
b:com.raycloud.dmj.data.utils.BeanB@586fb16d,b.c:com.raycloud.dmj.data.utils.BeanC@ce99877
c:com.raycloud.dmj.data.utils.BeanC@ce99877,c.a:com.raycloud.dmj.data.utils.BeanA@46bfc63c
可以看到单例setter循环依赖没有报错,且循环的依赖都成功set。具体实现原理后面详细看

原型setter


        
    
    
        
    
    
        
    

同样报错:
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源码解析-6、spring单例如何解决循环依赖_第1张图片
如图,set方法注入,spring先实例化Bean[通过无参构造器],在设置属性,这样就不会报错了。
具体如何解决循环依赖
以我们的实例来说,spring会先实例化a,b,c,并放入一个map,然后设置属性,a设置属性b,只需要从mao中取出b即可,以此类推。

而事实上spring可不止这一个map,而是通过三级缓存来解决单例Bean的循环依赖。

三级缓存

/** Cache of singleton objects: bean name --> bean instance */
private final Map singletonObjects = new ConcurrentHashMap(256);
 
/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map> singletonFactories = new HashMap>(16);
 
/** Cache of early singleton objects: bean name --> bean instance */
private final Map earlySingletonObjects = new HashMap(16);

singletonObjects:存放单例对象实例的缓存
earlySingletonObjects:存在提前曝光的bean,也就是正在创建中的bean。
singletonFactories :创建单例对象的工厂

实现原理

实现原理的代码如下:

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//先从单例缓存中取
		Object singletonObject = this.singletonObjects.get(beanName);
		//一级缓存中没有,并且判断正在创建中【比如A的构造器依赖B,或者已经实例化正在setB  ,所以先去创建B,那么A就是创建中】
		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;
	}

简单来说:
在创建单例Bean的时候是这样解决循环依赖的。
假设A B互相依赖。
先通过createBean创建A,会先走createInstance来实例化A,然后把A的单例工厂放到三级缓存,实例化后需要设置属性,发现需要B,但是B没有初始化,因此通过createBean创建,同样需要实例化,实例化以后发现依赖A,因此先去单例缓存中找,因为A还在创建中,所以找不到,然后去二级缓存找,依旧找不到,因此最后通过单例工厂创建获取了A,B就创建好了,B创建好了,就set给A,此时A.B都实例化成功了。

你可能感兴趣的:(死磕spring源码)