当Spring循环依赖遇上了BeanPostProcessor动

1.什么是循环依赖

假设Spring容器中有两个Bean：A和B

依赖关系如下：

A->B->A

@Component
public class CircularA {

    @Autowired
    private CircularB b;

    public CircularA() {
    }

    public void setB(CircularB b) {
        this.b = b;
    }
}
@Component
public class CircularB {

    @Autowired
    private CircularA a;

    public CircularB() {
    }

    public void setA(CircularA a) {
        this.a = a;
    }
}

Spring容器在创建BeanA的时候，发现需要依赖BeanB，那么在创建BeanB的时候，发现需要依赖BeanA，如此就形成循环依赖。

2. Spring怎么解决循环依赖

在网上有很多相关的博客解释Spring如何解决循环依赖Spring解决循环依赖。

简而言之就是Spring通过三级缓存来解决循环依赖。在Spring容器初始化过程中，通过beanName获取Bean的优先级依次是：一级缓存->二级缓存->三级缓存

    /** Cache of singleton objects: bean name --> bean instance */
    /** 一级缓存 */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

    /** Cache of singleton factories: bean name --> ObjectFactory */
    /** 三级缓存 */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

    /** Cache of early singleton objects: bean name --> bean instance */
    /** 三级缓存 */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

当BeanFactory实例化BeanA后，BeanFactory会把刚刚实例化还没有依赖注入的Bean包装成一个ObjectFactory对象放入到三级缓存中，并且从二级缓存中移除，代码如下

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

接下来进行依赖注入，如果存在循环依赖，例如A->B->A的情况，A实例化完毕，注入A.b的时候，要实例化B，发现依赖a，这个时候就要从BeanFactory中获取a实例，这个时候，缓存升级了。下面方法的第二个参数是true

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        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();
            /** 将获取到的Bean从三级缓存中移除，并且升级到二级缓存中 */
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

b实例自己先完成实例化和依赖注入（这个时候a实例只是刚刚实例化，但是已经可以满足beanB的需求了）以及初始化等声明周期，最后在返回到a的创建流程中，a实例就可以注入已经成熟的b实例,a实例自身也顺利完成创建，由于b实例持有了a实例的引用，所以在后续的使用中是完全没有问题的。

如果Spring中不存在Bean的循环依赖，应该是不存在从三级缓存升级到二级缓存的场景，因为Spring是单线程初始化的。

这样Spring解决Bean循环依赖的问题！！！

3. BeanPostProcessor

BeanPostProcessor接口是用来对bean进行后置处理的，这个时候bean已经完成实例化和依赖注入了，属于bean初始化生命周期的一部分。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

如果在BeanPostProcessor的接口中，对传入的bean进行了处理导致返回的bean和传入的bean不是同一个bean，这个正常情况是没有问题，很多中间件都是这么做的

但是！！！当Spring 循环依赖遇上BeanProcessor返回一个不一致对象的时候，就会发生问题了！！！

4. 异常情况

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'xxx': Bean with name 'xxx' has been injected into other beans [a,b,c] 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.

问题的描述就是这个样子了，大致的意思就是xxx这个bean已经注入到很多bean中了，只不过呢依赖xxx的bean中引用的不是它的最终版本，因为他们之间存在循环依赖的问题，在解决循环依赖中使用的是二级缓存中的early bean，而解决完循环依赖后，bean的引用发生了变化，导致了early bean和 expose bean不相等，所以抛出异常了！！！

Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<String>(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.");
                    }
                }
            }

5. 解决方案

找到问题原因了，那么问题的解决通常就有了

1. 项目中尽量避免Spring的循环引用，这本来就是不合理的。

2. 使用@Lazy加载机制来解决