Spring如何解决循环依赖的

    /** 一级缓存 单例缓存池 用于保存我们所有的单实例bean */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /** 二级缓存 保存半成品bean实例，当对象需要被AOP切面代时，保存代理bean的实例beanProxy*/
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);


    /** 三级缓存 存放ObjectFactory，传入的是匿名内部类，ObjectFactory.getObject() 方法最终会
      调用getEarlyBeanReference()进行处理，返回创建bean实例化的lambda表达式。*/
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

//一个纯bean获取流程，这里不进行创建
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从一级缓存singletonObjects获取bean
    Object singletonObject = this.singletonObjects.get(beanName);
    // 一级缓存没有，判断该bean是否在创建中，通过Set的contains来判断
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 从二级缓存中获取bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 二级缓存没有&&允许提前引用
            if (singletonObject == null && allowEarlyReference) {
                // 从三级缓存中获取lambda表达式
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
               // 如果获取到该lambda表达式，进行回调填充
                if (singletonFactory != null) {
                    // 调用三级缓存的lambda表示获取早期不完整对象
                    singletonObject = singletonFactory.getObject();
                    // 写入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 三级缓存移除该bean的lambda表达式
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

    protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {
        ... ... ...
        //先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            ... ... ... 
        }else {
            ... ... ...
            try {
                ... ... ...
                if (mbd.isSingleton()) {
                    //getSingleton方法触发createBean回调，进行bean的生命周期  
                    //这里会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
            ... ... ...
        }
        return (T) bean;
    }

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) {
                ... ... ...
                // 会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
                beforeSingletonCreation(beanName);
                ... ... ...
                try {
                    // lambda表达式回到createBean
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
            ... ... ... 
            }
            return singletonObject;
        }
    }

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    ... ... ...
    if (instanceWrapper == null) {
        // a. 一般通过createBeanInstancec实例化不完整的BeanServiceA对象
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    ... ... ...
    // 默认单例&&默认循环引用&&该bean正在创建，条件成立
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        ... ... ...
        // b. 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // c. 属性填充BeanServiceB
        populateBean(beanName, mbd, instanceWrapper);
        // d.初始化时调用AOP后置处理器进行AOP处理
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    ... ... ...
    // e.处理提前暴露的场景，保证返回同一个代理对象
    if (earlySingletonExposure) {
        // 见上文第1节的节速，由于第二个参数是false，所以只会查到第二季缓存
        // 所以这里就是查看第二级缓存能不能取到值，取到就意味着涉及提前AOP
        Object earlySingletonReference = getSingleton(beanName, false);
        // 涉及提前AOP，从二级缓存中获取提前AOP的代理对象
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                // 保证循环依赖且涉及AOP时，返回同一个代理对象，下文有结束
                exposedObject = earlySingletonReference;
            }
            ... ... ...
        }
    }
    return exposedObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            // 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        //遍历后置处理器
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                // 调用后置处理器的getEarlyBeanReference进行提前暴露bean
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    // 写入earlyProxyReferences，在后面postProcessAfterInitialization会用到
    this.earlyProxyReferences.put(cacheKey, bean);
    // 判断是否创建代理对象
    return wrapIfNecessary(bean, beanName, cacheKey);
}

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) {
                ... ... ...
                // 会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
                beforeSingletonCreation(beanName);
                ... ... ...
                try {
                    // lambda表达式回到createBean
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                ... ... ..
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    // singletonsCurrentlyInCreation中移除beanName，表示该bean不是正在创建了
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    // 将不完整的beanServiceB对象写入一级缓存，移除二、三级缓存
                    addSingleton(beanName, singletonObject);
                }
            }
            return 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);
    }
}