Spring 循环依赖

A->B->A
A->C->A

AbstractApplicationContext.refresh()
-> AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)
-> DefaultLisableBeanFactory.preInstantiateSingletons()
-> AbstractBeanFactory.getBean(beanA)
-> AbstractBeanFactory.doGetBean(beanA)

Object sharedInstance = getSingleton(beanName);

public Object getSingleton(String beanName) {
    // 注意第二个参数为 true
    return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 此时 beanA 还没有开始创建，这里一定返回 null
    Object singletonObject = this.singletonObjects.get(beanName);
    // 由于 beanA 还没有开始创建，因此也不会存在于 singletonsCurrentlyInCreation
    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;
}

// 第二个参数是一个类似于 java.util.function.Supplier 的函数式接口
// 用于创建 beanA
sharedInstance = getSingleton(beanName, () -> {
    try {
        return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
        destroySingleton(beanName);
        throw ex;
    }
});

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) {
            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 + "'");
            }
            // 该方法会将 beanA 添加到 singletonsCurrentlyInCreation
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                // 此处调用函数式接口进行 beanA 的创建
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

AbstractAutowireCapableBeanFactory.createBean()
-> AbstractAutowireCapableBeanFactory.doCreateBean(beanName, mbdToUse, args)

instanceWrapper = createBeanInstance(beanName, mbd, args);

// 这里的参数 bean 是刚刚实例化完毕的 beanA
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

populateBean(beanName, mbd, instanceWrapper);

DefaultListableBeanFactory.doResolveDependency()
-> DependencyDescriptor.resolveCandidate("beanB", BeanB.class, beanFactory)
-> beanFactory.getBean("beanB")