Spring源码最难问题：当循环依赖遇上Spring AOP

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

        final String beanName = transformedBeanName(name);
        Object bean;

        // 2. 尝试从缓存中获取bean
        Object sharedInstance = getSingleton(beanName);
        ...
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从一级缓存获取，key=beanName value=bean
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 从二级缓存获取，key=beanName value=bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 是否允许循环引用
            if (singletonObject == null && allowEarlyReference) {
               /**
                * 三级缓存获取，key=beanName value=objectFactory，objectFactory中存储getObject()方法用于获取提前曝光的实例
                *
                * 而为什么不直接将实例缓存到二级缓存，而要多此一举将实例先封装到objectFactory中？
                * 主要关键点在getObject()方法并非直接返回实例，而是对实例又使用
                * SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法对bean进行处理
                *
                * 也就是说，当spring中存在该后置处理器，所有的单例bean在实例化后都会被进行提前曝光到三级缓存中，
                * 但是并不是所有的bean都存在循环依赖，也就是三级缓存到二级缓存的步骤不一定都会被执行，有可能曝光后直接创建完成，没被提前引用过，
                * 就直接被加入到一级缓存中。因此可以确保只有提前曝光且被引用的bean才会进行该后置处理
                */
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    /**
                    * 通过getObject()方法获取bean，通过此方法获取到的实例不单单是提前曝光出来的实例，
                    * 它还经过了SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法处理过。
                    * 这也正是三级缓存存在的意义，可以通过重写该后置处理器对提前曝光的实例，在被提前引用时进行一些操作
                    */
                    singletonObject = singletonFactory.getObject();
                    // 将三级缓存生产的bean放入二级缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 删除三级缓存
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

this.addSingletonFactory(beanName, () -> {
    return this.getEarlyBeanReference(beanName, mbd, bean);
});

// AbstractAutoProxyCreator.java
public Object getEarlyBeanReference(Object bean, String beanName) {
    // 缓存当前bean，表示该bean被提前代理了
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    // 对bean进行提前Spring AOP代理
    return wrapIfNecessary(bean, beanName, cacheKey);
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 调用bean初始化后置处理器处理
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

// AbstractAutoProxyCreator.java
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 获取缓存key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 查看该bean是否被Spring AOP提前代理！而缓存的是原始的bean，因此如果bean被提前代理过，这此处会跳过
        // 如果bean没有被提前代理过，则进入AOP代理
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
    try {
        //
        /**
        * 4. 填充属性
        * 如果@Autowired注解属性，则在上方完成解析后，在这里完成注入
        *
        * @Autowired
        * private Inner inner;
        */
        populateBean(beanName, mbd, instanceWrapper);
        // 5. 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    // 6. 存在提前曝光情况下
    if (earlySingletonExposure) {
        // earlySingletonReference：二级缓存，缓存的是经过提前曝光提前Spring AOP代理的bean
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            // exposedObject跟bean一样，说明初始化操作没用应用Initialization后置处理器(指AOP操作)改变exposedObject
            // 主要是因为exposedObject如果提前代理过，就会跳过Spring AOP代理，所以exposedObject没被改变，也就等于bean
            if (exposedObject == bean) {
                // 将二级缓存中的提前AOP代理的bean赋值给exposedObject，并返回
                exposedObject = earlySingletonReference;
            }
            // 引用都不相等了，也就是现在的bean已经不是当时提前曝光的bean了
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // dependentBeans也就是B, C, D
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 被依赖检测异常
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                        "Bean with name '" + beanName + "' has been injected into other beans [" +
                        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                        "] in its raw version as part of a circular reference, but has eventually been " +
                        "wrapped. This means that said other beans do not use the final version of the " +
                        "bean. This is often the result of over-eager type matching - consider using " +
                        "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
        //...
    }
}