Spring中的三级缓存与循环依赖详解

public class DefaultSingletonBeanRegistry 
    extends SimpleAliasRegistry 
    implements SingletonBeanRegistry {
    /** Cache of singleton factories: bean name to ObjectFactory. */
    private Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    /** Cache of early singleton objects: bean name to bean instance. */
    private Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    /** Cache of singleton objects: bean name to bean instance. */
    private Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    // ...
}

// --------------------------- AbstractBeanFactory ---------------------------
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}
// --------------------------- AbstractBeanFactory ---------------------------
protected <T> T doGetBean(
    String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
    // ...
    // 我们直接看主流程
    // Create bean instance.
    if (mbd.isSingleton()) {
        // 这里调用 DefaultSingletonBeanRegistry#getSingleton()
        // 参数一为 beanName
        // 参数二为 ObjectFactory 函数式对象
        sharedInstance = getSingleton(beanName, () -> {
            try {
                return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
                destroySingleton(beanName);
                throw ex;
            }
        });
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    // ...
}

// ------------------------ DefaultSingletonBeanRegistry -----------------------
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        // 1. 先从一级缓存中去获取
        // 如果获取到了 bean 对象，直接返回
        // 没有获取到 bean 对象的话，进入后续创建 bean 对象流程
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException();
            }
            // ...
            try {
                // 2. 调用 ObjectFactory 对象的 getObject() 创建得到 bean 对象
                // 从上述分析我们知道最终实现是 return createBean()
                // 我们需要看 createBean() 流程
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            } finally {
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 3. 创建 bean 成功的情况下
                // 将 bean 对象放入到一级缓存 singletonObjects 中
                // 并将 beanName 对应的值从二级缓存、三级缓存中移除
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}
// ------------------------ DefaultSingletonBeanRegistry -----------------------
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 将 bean 对象放入一级缓存中
        // 并将 beanName 对应的值从二级缓存、三级缓存中移除
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

// --------------------- AbstractAutowireCapableBeanFactory -------------------
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    RootBeanDefinition mbdToUse = mbd;
    // ...
    try {
        // 调用 doCreateBean() 创建出 bean 对象，并返回该 bean 对象
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        return beanInstance;
    } catch (Throwable ex) {
        throw new BeanCreationException();
    }
}
// --------------------- AbstractAutowireCapableBeanFactory -------------------
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, 
                              Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 1. 实例化对象
        // 根据合适的构造方法构造出实例 bean 对象
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
    // 2. 是否应该使用三级缓存，一般情况下都会使用三级缓存
    boolean earlySingletonExposure = (mbd.isSingleton() && 
                                      this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 3. 将 beanName 和对应的函数式对象 ObjectFactory 放入到三级缓存中
        // 该 ObjectFactory 已经拿到了刚刚实例化好的 bean 对象，只不过只执行了构造函数
        // 该 ObjectFactory 的 getObject() 实现是调用 getEarlyBeanReference()
        addSingletonFactory(beanName,
                            () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // 4. 初始化 Bean 对象 
    Object exposedObject = bean;
    try {
        // 4.1 属性注入
        // 如果 A 依赖 B，getBean(A) 时会去调 getBean(B)
        // 如果 A、B 出现循环依赖，会出现 getBean(A) -> getBean(B) -> getBean(A) 的情况
        populateBean(beanName, mbd, instanceWrapper);
        // 4.2 初始化 bean 对象
        // 这里会执行一些 BeanPostProcessor 的后处理方法
        // 我们熟悉的 Spring AOP 就是在这里生成的代理类对象的
        // 如 @Transactional 使用的后处理器是 AbstractAutoProxyCreator
        // 如 @Async 使用的后处理器是 AbstractAdvisingBeanPostProcessor
        // 虽然都是生成 AOP 对象，但是这两者在处理循环依赖时处理逻辑不一样，后面细讲
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        throw ex;
    }
    if (earlySingletonExposure) {
        // 5. 决定 getBean(A) 是返回 bean 对象还是抛出异常
        // 参数二是 false
        // 从一级缓存或者二级缓存中获取 bean 对象
        // 走到这里一般是尝试从二级缓存中获取 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<>();
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException();
                }
            }
        }
    }
    // 6. 注册删除 bean 逻辑
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException();
    }
    // 7. 返回 bean 对象
    return exposedObject;
}