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 對象的話，進入后續(xù)創(chuàng)建 bean 對象流程
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException();
            }
            // ...
            try {
                // 2. 調用 ObjectFactory 對象的 getObject() 創(chuàng)建得到 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. 創(chuàng)建 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() 創(chuàng)建出 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 對象，只不過只執(zhí)行了構造函數
        // 該 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 出現循環(huán)依賴，會出現 getBean(A) -> getBean(B) -> getBean(A) 的情況
        populateBean(beanName, mbd, instanceWrapper);
        // 4.2 初始化 bean 對象
        // 這里會執(zhí)行一些 BeanPostProcessor 的后處理方法
        // 我們熟悉的 Spring AOP 就是在這里生成的代理類對象的
        // 如 @Transactional 使用的后處理器是 AbstractAutoProxyCreator
        // 如 @Async 使用的后處理器是 AbstractAdvisingBeanPostProcessor
        // 雖然都是生成 AOP 對象，但是這兩者在處理循環(huán)依賴時處理邏輯不一樣，后面細講
        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;
}