关于java:spring-循环依赖问题研究

CASE:“A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”。
剖析：
1.A进行create流程，发现自己依赖B,此时B更没有走create流程。
doCreateBean()中

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));

isSingletonCurrentlyInCreation(beanName)的具体实现是：

protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

那么它的调用机会又是什么时候呢？
DefaultSingletonBeanRegistry.getSingleton();
AbstractBeanFactory.doGetBean()中也就是AbstractBeanFactory.getBean()调用了下面这个办法.
在这里还有一个调用链路就是:
AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)->

    beanFactory.preInstantiateSingletons()->AbstractBeanFactory.getBean().

在这里，我目前先探讨这两个次要的调用链路，其余的当前再说。
咱们接着剖析，如果判断出循环援用，则执行addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))。
看一下具体实现：

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

见到了相熟的singletonFactories，是不是很兴奋呢；此时，A将本人放入到singletonFactories中。
2.发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以B走create流程。
3.B初始化时时候发现自己依赖A，尝试get(A)，从singletonObjects(一级缓存)中取，发现没有（此时A还没有初始化实现），earlySingletonObjects（二级缓存）中也没有，最初从singletonFactories（三级缓存）中取，因为在1中A曾经寄存在singletonFactories外面了，所以B能够拿到A(尽管是个半成品)。
4.此时，B能够顺利完成初始化，并将本人放在singletonObjects中。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                if (newSingleton) {
                    //增加到singletonObjects中
                    addSingleton(beanName, singletonObject);
                }
}

上面看，具体实现：

protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.put(beanName, singletonObject);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

5.此时返回A中，A此时能拿到B,最终A也实现了初始化，进去了一级缓存singletonObjects中。