Spring中循环依赖的解决方法详析
前言
说起spring中循环依赖的解决办法，相信很多园友们都或多或少的知道一些，但当真的要详细说明的时候，可能又没法一下将它讲清楚。本文就试着尽自己所能，对此做出一个较详细的解读。另，需注意一点，下文中会出现类的实例化跟类的初始化两个短语，为怕园友迷惑，事先声明一下，本文的实例化是指刚执行完构造器将一个对象new出来，但还未填充属性值的状态，而初始化是指完成了属性的依赖注入。
一、先说说spring解决的循环依赖是什么
java中的循环依赖分两种，一种是构造器的循环依赖，另一种是属性的循环依赖。
构造器的循环依赖就是在构造器中有属性循环依赖，如下所示的两个类就属于构造器循环依赖：
@service
public class student {
@autowired
private teacher teacher;
public student (teacher teacher) {
system.out.println("student init1:" + teacher);
}
public void learn () {
system.out.println("student learn");
}
}
@service
public class teacher {
@autowired
private student student;
public teacher (student student) {
system.out.println("teacher init1:" + student);
}
public void teach () {
system.out.println("teach:");
student.learn();
}
}
这种循环依赖没有什么解决办法，因为jvm虚拟机在对类进行实例化的时候，需先实例化构造器的参数，而由于循环引用这个参数无法提前实例化，故只能抛出错误。
spring解决的循环依赖就是指属性的循环依赖，如下所示：
@service
public class teacher {
@autowired
private student student;
public teacher () {
system.out.println("teacher init1:" + student);
}
public void teach () {
system.out.println("teach:");
student.learn();
}
}
@service
public class student {
@autowired
private teacher teacher;
public student () {
system.out.println("student init:" + teacher);
}
public void learn () {
system.out.println("student learn");
}
}
测试扫描类：
@componentscan(value = "mypackage")
public class scanconfig {
}
测试启动类：
public class springtest {
public static void main(string[] args) {
annotationconfigapplicationcontext applicationcontext = new annotationconfigapplicationcontext(scanconfig.class);
applicationcontext.getbean(teacher.class).teach();
}
}
测试类执行结果：
student init:null teacher init:null teach: student learn
可以看到，在构造器执行的时候未完成属性的注入，而在调用方法的时候已经完成了注入。下面就一起看看spring内部是在何时完成的属性注入，又是如何解决的循环依赖。
二、循环依赖与属性注入
1、对于非懒加载的类，是在refresh方法中的 finishbeanfactoryinitialization(beanfactory) 方法完成的包扫描以及bean的初始化，下面就一起追踪下去。
protected void finishbeanfactoryinitialization(configurablelistablebeanfactory beanfactory) {
// 其他代码
// instantiate all remaining (non-lazy-init) singletons.
beanfactory.preinstantiatesingletons();
}
可以看到调用了beanfactory的一个方法，此处的beanfactory就是指我们最常见的那个defaultlistablebeanfactory，下面看它里面的这个方法。
2、defaultlistablebeanfactory的preinstantiatesingletons方法
public void preinstantiatesingletons() throws beansexception {
list<string> beannames = new arraylist<>(this.beandefinitionnames);
// trigger initialization of all non-lazy singleton beans...
for (string beanname : beannames) {
rootbeandefinition bd = getmergedlocalbeandefinition(beanname);
if (!bd.isabstract() && bd.issingleton() && !bd.islazyinit()) { // 判断为非抽象类、是单例、非懒加载 才给初始化
if (isfactorybean(beanname)) {
// 无关代码（针对factorybean的处理）
}
else {
// 重要！！！普通bean就是在这里初始化的
getbean(beanname);
}
}
}
// 其他无关代码
}
可以看到，就是在此方法中循环spring容器中所有的bean，依次对其进行初始化，初始化的入口就是getbean方法
3、abstractbeanfactory的getbean跟dogetbean方法
追踪getbean方法：
public object getbean(string name) throws beansexception {
return dogetbean(name, null, null, false);
}
可见引用了重载的dogetbean方法，继续追踪之：
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;
// 方法1）从三个map中获取单例类
object sharedinstance = getsingleton(beanname);
// 省略无关代码
}
else {
// 如果是多例的循环引用，则直接报错
if (isprototypecurrentlyincreation(beanname)) {
throw new beancurrentlyincreationexception(beanname);
}
// 省略若干无关代码
try {
// create bean instance.
if (mbd.issingleton()) {
// 方法2) 获取单例对象
sharedinstance = getsingleton(beanname, () -> {
try { //方法3) 创建objectfactory中getobject方法的返回值
return createbean(beanname, mbd, args);
}
catch (beansexception ex) {
// explicitly remove instance from singleton cache: it might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// also remove any beans that received a temporary reference to the bean.
destroysingleton(beanname);
throw ex;
}
});
bean = getobjectforbeaninstance(sharedinstance, name, beanname, mbd);
}
}
// 省略若干无关代码
return (t) bean;
}
该方法比较长，对于解决循环引用来说，上面标出来的3个方法起到了至关重要的作用，下面我们挨个攻克。
3.1） getsingleton(beanname)方法： 注意该方法跟方法2）是重载方法，名字一样内部逻辑却大相径庭。
protected object getsingleton(string beanname, boolean allowearlyreference) {
object singletonobject = this.singletonobjects.get(beanname);// 步骤a
if (singletonobject == null && issingletoncurrentlyincreation(beanname)) {
synchronized (this.singletonobjects) {
singletonobject = this.earlysingletonobjects.get(beanname);// 步骤b
if (singletonobject == null && allowearlyreference) {
objectfactory<?> singletonfactory = this.singletonfactories.get(beanname);// 步骤c
if (singletonfactory != null) {
singletonobject = singletonfactory.getobject();
this.earlysingletonobjects.put(beanname, singletonobject);
this.singletonfactories.remove(beanname);
}
}
}
}
return singletonobject;
}
通过上面的步骤可以看出这三个map的优先级。其中singletonobjects里面存放的是初始化之后的单例对象；earlysingletonobjects中存放的是一个已完成实例化未完成初始化的早期单例对象；而singletonfactories中存放的是objectfactory对象，此对象的getobject方法返回值即刚完成实例化还未开始初始化的单例对象。所以先后顺序是，单例对象先存在于singletonfactories中，后存在于earlysingletonobjects中，最后初始化完成后放入singletonobjects中。
当debug到此处时，以上述teacher和student两个循环引用的类为例，如果第一个走到这一步的是teacher，则从此处这三个map中get到的值都是空，因为还未添加进去。这个方法主要是给循环依赖中后来过来的对象用。
3.2）getsingleton(string beanname, objectfactory<?> singletonfactory)方法：
public object getsingleton(string beanname, objectfactory<?> singletonfactory) {
assert.notnull(beanname, "bean name must not be null");
synchronized (this.singletonobjects) {
object singletonobject = this.singletonobjects.get(beanname);
if (singletonobject == null) {
// 省略无关代码
beforesingletoncreation(beanname); // 步骤a
boolean newsingleton = false;
// 省略无关代码
try {
singletonobject = singletonfactory.getobject();// 步骤b
newsingleton = true;
}
// 省略无关代码
finally {
if (recordsuppressedexceptions) {
this.suppressedexceptions = null;
}
aftersingletoncreation(beanname);// 步骤c
}
if (newsingleton) {
addsingleton(beanname, singletonobject);// 步骤d
}
}
return singletonobject;
}
}
获取单例对象的主要逻辑就是此方法实现的，主要分为上面四个步骤，继续挨个看：
步骤a：
protected void beforesingletoncreation(string beanname) {
// 判断，并首次将beanname即teacher放入singletonscurrentlyincreation中
if (!this.increationcheckexclusions.contains(beanname) && !this.singletonscurrentlyincreation.add(beanname)) {
throw new beancurrentlyincreationexception(beanname);
}
}
步骤c：
protected void aftersingletoncreation(string beanname) {
// 得到单例对象后，再讲beanname从singletonscurrentlyincreation中移除
if (!this.increationcheckexclusions.contains(beanname) && !this.singletonscurrentlyincreation.remove(beanname)) {
throw new illegalstateexception("singleton '" + beanname + "' isn't currently in creation");
}
}
步骤d：
protected void addsingleton(string beanname, object singletonobject) {
synchronized (this.singletonobjects) {
this.singletonobjects.put(beanname, singletonobject);//添加单例对象到map中
this.singletonfactories.remove(beanname);//从早期暴露的工厂中移除，此map在解决循环依赖中发挥了关键的作用
this.earlysingletonobjects.remove(beanname);//从早期暴露的对象map中移除
this.registeredsingletons.add(beanname);//添加到已注册的单例名字集合中
}
}
步骤b：
此处调用了objectfactory的getobject方法，此方法是在哪里实现的呢？返回的又是什么？且往回翻，找到3中的方法3，对java8函数式编程有过了解的园友应该能看出来，方法3 【createbean(beanname, mbd, args)】的返回值就是getobject方法的返回值，即方法3返回的就是我们需要的单例对象，下面且追踪方法3而去。
3.3）abstractautowirecapablebeanfactory#createbean(java.lang.string, org.springframework.beans.factory.support.rootbeandefinition, java.lang.object[]) 方法
protected object createbean(string beanname, rootbeandefinition mbd, @nullable object[] args)
throws beancreationexception {
// 省略无关代码
try {
object beaninstance = docreatebean(beanname, mbdtouse, args);
return beaninstance;
}
// 省略无关代码
}
去掉无关代码之后，关键方法只有docreatebean方法，追踪之：
protected object docreatebean(final string beanname, final rootbeandefinition mbd, final @nullable object[] args)
throws beancreationexception {
beanwrapper instancewrapper = null;
// 省略代码
if (instancewrapper == null) {
// 实例化bean
instancewrapper = createbeaninstance(beanname, mbd, args);
}
boolean earlysingletonexposure = (mbd.issingleton() && this.allowcircularreferences &&
issingletoncurrentlyincreation(beanname));
if (earlysingletonexposure) {
// 重点！！！将实例化的对象添加到singletonfactories中
addsingletonfactory(beanname, () -> getearlybeanreference(beanname, mbd, bean));
}
// 初始化bean
object exposedobject = bean;
try {
populatebean(beanname, mbd, instancewrapper);//也很重要
exposedobject = initializebean(beanname, exposedobject, mbd);
}
// 省略无关代码
return exposedobject;
}
上面注释中标出的重点是此方法的关键。在addsingletonfactory方法中，将第二个参数objectfactory存入了singletonfactories供其他对象依赖时调用。然后下面的populatebean方法对刚实例化的bean进行属性注入（该方法关联较多，本文暂时不展开追踪了，有兴趣的园友自行查看即可），如果遇到spring中的对象属性，则再通过getbean方法获取该对象。至此，循环依赖在spring中的处理过程已经追溯完毕，下面我们总结一下。
小结
属性注入主要是在populatebean方法中进行的。对于循环依赖，以我们上文中的teacher中注入了student、student中注入了teacher为例来说明，假定spring的加载顺序为先加载teacher，再加载student。
getbean方法触发teacher的初始化后：
a. 首先走到3中的方法1），此时map中都为空，获取不到实例；
b. 然后走到方法2）中，步骤a、步骤c、步骤d为控制map中数据的方法，实现简单，可暂不关注。其中步骤b的getobject方法触发对方法3)的调用；
c. 在方法3）中，先通过createbeaninstance实例化teacher对象，又将该实例化的对象通过addsingletonfactory方法放入singletonfactories中，完成teacher对象早期的暴露；
d. 然后在方法3）中通过populatebean方法对teacher对象进行属性的注入，发现它有一个student属性，则触发getbean方法对student进行初始化
e. 重复a、b、c步骤，只是此时要初始化的是student对象
f. 走到d的时候，调用populatebean对student对象进行属性注入，发现它有一个teacher属性，则触发getbean方法对teacher进行初始化；
g. 对teacher进行初始化，又来到a，但此时map已经不为空了，因为之前在c步骤中已经将teacher实例放入了singletonfactories中，a中得到teacher实例后返回；
h.完成f中对student的初始化，继而依次往上回溯完成teacher的初始化；
完成teacher的初始化后，student的初始化就简单了，因为map中已经存了这个单例。
至此，spring循环依赖的总结分析结束，一句话来概括一下：spring通过将实例化后的对象提前暴露给spring容器中的singletonfactories，解决了循环依赖的问题。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。