Spring-bean的循环依赖以及解决方式

什么是循环依赖

循环依赖就是循环引用，每个类中嵌套引用，在spring中表现为两个或多个bean相互之间持有对方，比如A引用B，B引用C，C又引用A，最终反映出来形成一个环。循环调用时无法解决的，一定要有终止条件才可以，否则就是死循环，最终的结果就是内存溢出。

spring中的循环依赖场景

1. 构造器的循环依赖
2. field属性的循环依赖

构造器循环依赖

通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyInCreationException
描述：创建A时，构造器需要B，那将去创建B，完了发现需要C，完了发现又需要A，从而形成一个环。
原理：Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中，bean标识符创建过程中将一直保持在这个池中，因为如果在创建bean过程中发现自己已经在“当前创建bean池”中时，将会抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的bean将从“当前创建bean池”中清除掉。因为在池中的Bean都是未初始化完的，所以会依赖错误 ，（初始化完的Bean会从池中移除）

过程分析：(构造器依赖 A -> B -> C -> A)：

1. Spring容器创建A bean，首先去 “当前创建bean池”中查找是否当前bean正在创建（通过beanName），如果发现没有，则继续准备其需要的构造器参数B，并将A标识符放到“当前创建bean池”
2. Spring容器创建B bean，Spring容器创建B bean，首先去 “当前创建bean池”中查找是否当前bean正在创建（通过beanName），如果发现没有，则继续准备其需要的构造器参数C，并将B标识符放到“当前创建bean池”
3. Spring容器创建C bean，Spring容器创建C bean，首先去 “当前创建bean池”中查找是否当前bean正在创建（通过beanName），如果发现没有，则继续准备其需要的构造器参数A，并将C标识符放到“当前创建bean池”
4. 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

1. 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循环依赖的解决方案