Spring源码解析之循环依赖

什么是循环依赖？

循环依赖：在依赖注入的过程中，多个Bean对象互相持有对方的引用，比如A对象中包含B对象，B对象中包含A对象，以此类推，它们看上去就像是一个圆环，首尾相连。

了解完之后你可能会有疑问：这样的情况会引发什么问题？

所谓知其然还要知其所以然，所以解决问题之前我们还需要思考它发生的原因。

Spring中的循环依赖

原因

首先我们需要结合Spring中Bean的实例化规则，而前一篇关于解析Spring依赖注入的源码内容中（Spring源码解析之DI篇如果不清楚DI原理小伙伴推荐先了解完再来看循环依赖，相信更加容易理解），已经清楚的知道Spring在预实例化Bean之前有几种情况会先实例化其依赖的Bean对象，这样下来大概会出现什么情况呢，我们简单画一下，

是不是发现不对劲了，它们就像一个循环递归，除非有终结条件，否则就是死循环，直到内存溢出异常。

发生场景与分析

既然知道了问题发生的原因，心急的朋友可能就直接考虑Spring的解决方案了，但是不要急，这只是初步的设想，我们还得具体的分析下不同场景下的发生的循环依赖。上面说了有一些情况实例化Bean之前会先实例化其依赖的Bean对象，那么会有哪些情况呢？接下来我们先分别罗列验证下。

首先我们知道Spring中Bean的作用域其实可以分为三种：单例（singleton）、原型（prototype）、其它（request、session、application、websocket）。而Bean实例化的源码中也是根据这三种Scope分别选择不同的实例化策略，看下源码（无关代码暂时省略）

    protected  T doGetBean(final String name, @Nullable final Class requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
            ......

                //创建单例Bean对象
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            //创建Bean实例
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            //清除Bean实例
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                //创建原型Bean对象
                else if (mbd.isPrototype()) {
                    Object prototypeInstance = null;
                    try {
                        //创建前回调，默认实现将beanName注册为当前正在创建的原型Bean
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        //创建后回调，默认实现移除刚注册的原型Bean的beanName
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                //创建的非单例、非原型的Bean
                else {
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    //没有配置作用域，则抛出不合法异常
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new BeanCreationException(beanName,
                                "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                ex);
                    }
                }
        ......
        return (T) bean;
    }

相比单例只会保存一个对象来说，其中原型和其它都会产生多个对象，下面不同场景也会对单例、多例（原型）情况来分别验证。

开始之前我们先介绍两个会用到的属性：

/** 保存正在创建的单例Bean的beanName */
private final Set singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

/** 保存正在创建的原型Bean的beanName，其中Object可能是个String，有可能是个Set*/
private final ThreadLocal