Spring 如何解决 Bean 循环依赖问题

什么是循环依赖问题

循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。

Spring 如何解决循环依赖问题

简而言之Spring使用三级缓存来解决循环依赖的问题，三级缓存如下所示：

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


/** 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);

三级缓存分别为

singletonObjects：单例Bean缓存；
singletonFactories：单例Bean工厂缓存；
earlySingletonObjects：提前曝光的单例Bean缓存；

    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;
    }

获取单例Bean的大致过程如下：

首先从一级缓存singletonObjects中通过beanName获取单例bean；
若一级缓存中不存在该bean，并且isSingletonCurrentlyInCreation返回为true，那么通过earlySingletonObjects获取提前曝光的bean；
若二级缓存中不存在该bean，并且允许通过singletonFactories获取对象，那么通过工厂来创建bean。

isSingletonCurrentlyInCreation表示当前bean是否正在创建中，例如对象A通过构造函数依赖B，获取对象A在填充属性的过程中，发现通过成员变量的形式依赖对象B，那么需要先对B进行实例化，这种情况下，对象A的状态就是在正在创建中。

要理解Spring如何解决循环依赖问题，还需要了解Spring Bean的初始化过程，spring bean 的初始化大致可以分为如下过程

调用构造方法进行实例化；
填充对象属性；
通过init方法进行初始化

创建Bean的过程中，完成第一步骤，对象已经被生产出来了，只是对象缺失了一些属性，但是对象已经能够被引用了。

解决循环依赖的关键就是三级缓存，其中三级缓存singletonFactories是在方法addSingletonFactory中进行填充的，

    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);
            }
        }
    }

该方法被AbstractAutowireCapableBeanFactory类中的doCreateBean调用，那么在bean实例化之后，即调用了构造函数之后，singletonFactories已经被注册，通过singletonFactories，spring将未完整初始化的对象暴露出来，供其他类使用。

若对象A通过成员变量的形式依赖对象B，对象B通过循环依赖的形式依赖对象A，我们来看一下Spring解决循环依赖的步骤

对象A进行初始化，首先通过构造函数进行实例化，然后填充属性，发现依赖的对象B没有进行加载；
对象B进行初始化，首先通过构造函数进行实例化，然后填充属性，此时对象A以被提前暴露出来，对象B完成初始化；
对象A通过对象B完成属性填充，完成初始化。

通过spring解决循环依赖的原理，可以看出，对于相互通过构造函数产生的循环依赖是无法解决的，如对象A通过构造函数依赖对象B，同时对象B通过构造函数依赖对象A，此时Spring就无能为力了，因为对象A和对象B，都无法通过构造函数完成初始化来提前暴露自身。