@Component("foo")
public Class Foo {
    @Autowired
    private Bar bar;  // 稱 foo 依賴 bar
}

@Component("bar")
public Class Bar {
    @Autowired
    private Baz baz;  // bar 依賴 baz
}

@Component("baz")
public class Baz {
    @Autowired
    private Foo foo; // 形成了循環(huán)依賴，baz -> (依賴) foo -> bar -> baz ...
}

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'bar': Requested bean is currently in creation: Is there an unresolvable circular reference?

if (earlySingletonExposure) {
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

@Component
public class Foo {
    private Bar bar;
    @Autowired
    public Foo(@Lazy Bar bar) {
        this.bar = bar;
    }
}

@Component
public class Bar {
    private Foo foo;
    @Autowired
    public Bar(Foo foo) {  // 或者將對 foo 的依賴，注解為 @Lazy 表示使用時才初始化
        this.foo = foo;
    }
}

@Component
public class Bar {
    private Foo foo;
    @Autowired
    public void setFoo(Foo foo) {
        this.foo = foo;
    }
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 緩存中存在
        /**
        * 如果 beanName 是一個 FactoryBean，則獲取對應(yīng)的 Bean
        * 如果 beanName 是一個普通的 Bean，則返回這個 Bean 本身
        */ 
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // 緩存中不存在
        // 創(chuàng)建對象
        
        if (mbd.isSingleton()) {
            /**
            * 這里的 getSingleton 是 getSingleton(beanName) 的重載版本
            * 它接受一個 beanName 和 一個 ObjectFactory 作為參數(shù)
            * 調(diào)用 ObjectFactory#getObject 產(chǎn)生一個實(shí)例
            * 并通過 addSingleton(beanName, singletonObject); 將實(shí)例添加到 singletonObjects 中
            * 這里 createBean 的代碼就是前面提到的 Spring 創(chuàng)建 Bean 實(shí)例的過程 doCreateBean
            */
            sharedInstance = getSingleton(beanName, () -> {
                try {
                    return createBean(beanName, mbd, args);
                }
            });
            /**
            * 同前面分支中的作用一樣
            */
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
    }
    /**
    * 判斷 Bean 類型與 requiredType 類型是否一直，一致則直接返回，不一致則需要進(jìn)行轉(zhuǎn)換
    */
    return adaptBeanInstance(name, beanInstance, requiredType);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName);
    /**
    * 判斷第一級緩存中是否有完全可以可用的 Bean 實(shí)例，若有則返回；
    * 若沒有，則根據(jù)情況判斷
    * isSingletonCurrentlyInCreation(beanName) 檢查的是在 `Set<String> singletonsCurrentlyInCreation` 集合中是否包含要獲取的 Bean 實(shí)例
    * beanName 只在調(diào)用 beforeSingletonCreation(String beanName)  時被添加到 singletonsCurrentlyInCreation 集合中
    * beforeSingletonCreation 在創(chuàng)建 bean，即 doCreateBean 之前調(diào)用，在創(chuàng)建過程完成以后，調(diào)用 afterSingletonCreation 從集合中移除 beanName
    */
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
        /**
        * 執(zhí)行到這個分支，其實(shí)說明 Bean 已經(jīng)在創(chuàng)建過程中了，只不過是尚未完全可用（即一級緩存中沒有）
        * 檢查二級緩存，是否包含指定的 Bean
        * 
        * 二級緩存里的內(nèi)容何時被添加或設(shè)置進(jìn)來的呢？
        * 我們可以檢查下 earlySingletonObjects.put 方法都在哪里調(diào)用。
        * 檢查后發(fā)現(xiàn)，其實(shí) earlySingletonObjects 就是在當(dāng)前方法中設(shè)置的，我們接著往下看。
        */
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            /**
            * 這里的 allowEarlyReference 的意思就是指是否允許在二級緩存中創(chuàng)建一個對象，即是否允許暴露未完全可用的對象
            * 如果 allowEarlyReference 為假，則不會操作二級、三級緩存，而僅檢查一級緩存中是否有完全可用的 Bean 實(shí)例
            * 這也意味著，不允許返回未完全可用狀態(tài)的 Bean
            * 
            * 當(dāng)發(fā)現(xiàn)二級緩存中沒有對象，同時又允許提前引用（即 allowEarlyReference 值為真）
            * 則檢查三級緩存中是否有對應(yīng)的 ObjectFactory 對象，若有，則調(diào)用它的 getObject 方法產(chǎn)生對象，然后將其放置到二級緩存中，同時刪除三級緩存中的對象工廠實(shí)例
            * 若三級緩存中也沒有對象工廠實(shí)例，則說面 bean 還未創(chuàng)建
            */
            synchronized (this.singletonObjects) {
                /**
                * 這里會進(jìn)行一個 double-check，避免多線程間的線程安全問題
                */
                // Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            /**
                            * 三級緩存中存在對象工廠實(shí)例，則通過它產(chǎn)生一個 Bean 實(shí)例
                            * 加入到二級緩存中，同時刪除三級緩存中的對象工廠實(shí)例
                            */
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

sharedInstance = getSingleton(beanName, () -> {
    try {
        return createBean(beanName, mbd, args);
    }
});

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            /**
            * 檢查 Bean 是否在創(chuàng)建過程中，避免重復(fù)創(chuàng)建，
            * 不能解決的循環(huán)依賴也是在這里拋出異常
            */
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            try {
                /**
                * 這里調(diào)用的其實(shí)就是  AbstractAutowireCapableBeanFactory#createBean
                * 然后會執(zhí)行 doCreateBean（三個階段）
                */
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                throw ex;
            }
            finally {
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                /**
                * 這里說明一個 bean 創(chuàng)建過程的三個階段都執(zhí)行完畢了
                */
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}
/**
* 將 Bean 實(shí)例添加到第一級緩存
* 將第二級、第三級緩存中的對象刪除
*/
protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}