spring 三级缓存解决循环依赖

循环依赖

@Component
public class A {
    @Autowired
    private B b;

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }
}

@Component
public class B {
    @Autowired
    private A a;

    public A getA() {
        return a;
    }

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

在创建上述两个 bean 时，比如先创建 a，会有如下步骤发生：

1. a 实例化完成，初始化时发现要创建 b
2. b 实例化完成，初始化时发现要创建 a，此时第1步创建的 a 并未初始化完成，所以此时不能给 bean b 的属性 a 赋值，尝试创建 a
3. 重复第1~2步，产生循环问题

从上面的步骤可以看出来，循环依赖的核心问题在于完成实例化但未初始化的对象a不能被拿来使用（给对象b的属性a赋值），所以需要重新去创建对象a，从而产生循环问题。所以如果能提前将完成实例化但未初始化的半成品对象提前暴露出去，则可以解决循环依赖问题。

三级缓存

spring 中的三级缓存指的是三个 map

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    /** Cache of singleton objects: bean name --> bean instance */
    private final Map singletonObjects = new ConcurrentHashMap(256);

    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map> singletonFactories = new HashMap>(16);

    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map earlySingletonObjects = new HashMap(16);
}

public interface ObjectFactory {
    T getObject() throws BeansException;
}

• 一级缓存: singletonObjects 存放实例化、初始化都完成的 bean 对象
• 二级缓存: earlySingletonObjects 存放实例化完成但未初始化的 bean 对象
• 三级缓存: singletonFactories 存放 ObjectFactory 对象

第一级缓存用来存放实例化、初始化完成的单例对象；
第二级缓存提前暴露对象，解决循环依赖问题；
那么为什么需要第三级缓存呢？
第三级缓存存放的是一个对象工厂，是一个 lambda 表达式，即只有在 ObjectFactory 对象调用 getObject方法时，才会去执行对应的逻辑查找/创建 bean，也就是说缓存一个对象工厂，在需要 bean 对象时，调用 getObject 方法，这是 lambda 表达式的优点。
这似乎还是没有解释第三级缓存的意义，我们为何不是直接把实例化好的 bean 对象放在二级缓存中？而是将 ObjectFactory 对象存在三级缓存中。试想一下，在一个 spring 容器里，同名的单例 bean 对象只可能存在一个，对于 aop 场景中，我们不能返回原始 bean 对象，而是需要返回对应的代理对象，那么我们在创建 bean a 的时候是不知道应该提前暴露原始 bean 对象 a 还是应该暴露 a 对应的代理对象，只有当使用 bean a 的时候，例如给其他 bean b 的属性 a 赋值时才知道这件事，也就是属性赋值时才需要去查找/创建 a 或者 a 的代理对象，这就是第三级缓存的意义。
小结：提前暴露对象可以解决循环依赖问题，第三级缓存是为了解决 aop 场景的循环依赖问题。第一级和第二级缓存理论上是可以合并的，但是弊大于利，会让编码变的复杂。第三级缓存在没有 aop 的场景下理论上可以移除。

源码中 bean 的创建过程

以下源码部分不重要的内容已被省略
getBean → doGetBean → createBean → doCreateBean → createInstance → populateBean
① org.springframework.beans.factory.support.AbstractBeanFactory#getBean

    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

② org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

@SuppressWarnings("unchecked")
protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    // 通过 bean 的别名获取 bean 的原始名称
    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    // 从三级缓存中逐级查找 bean
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Create bean instance.
            if (mbd.isSingleton()) {
                // 重点在于此方法 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory)
                sharedInstance = getSingleton(beanName, new ObjectFactory