萬字長文帶你徹底吃透Spring迴圈依賴，堪稱全網最全（文末福利）

4.3 代理物件的setter迴圈依賴

Spring預設是不支援基於代理物件的setter方法的迴圈依賴，本節，就簡單實現一個基於代理物件的setter方法的迴圈依賴案例。具體實現步驟如下所示。

（1）新增ProxyCircularBeanA類

ProxyCircularBeanA類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.proxy.bean.ProxyCircularBeanA。

@Component
public class ProxyCircularBeanA {
    @Autowired
    private ProxyCircularBeanB proxyCircularBeanB;

    @Async
    public ProxyCircularBeanB getProxyCircularBeanB() {
        return proxyCircularBeanB;
    }
}

可以看到，ProxyCircularBeanA型別的Bean物件會依賴ProxyCircularBeanB型別的Bean物件，並且在getProxyCircularBeanB()方法上標註了@Async註解，當呼叫getProxyCircularBeanB()方法時，會透過AOP自動生成代理物件。

（2）新增ProxyCircularBeanB類

ProxyCircularBeanB類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.proxy.bean.ProxyCircularBeanB。

@Component
public class ProxyCircularBeanB {
    @Autowired
    private ProxyCircularBeanA proxyCircularBeanA;

    @Async
    public ProxyCircularBeanA getProxyCircularBeanA() {
        return proxyCircularBeanA;
    }
}

可以看到，ProxyCircularBeanB型別的Bean物件會依賴ProxyCircularBeanA型別的Bean物件，並且在getProxyCircularBeanA()方法上標註了@Async註解，當呼叫getProxyCircularBeanA()方法時，會透過AOP自動生成代理物件。

（3）新增ProxyCircularConfig類

ProxyCircularConfig類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.proxy.config.ProxyCircularConfig。

@EnableAsync
@Configuration
@ComponentScan(value = {"io.binghe.spring.annotation.chapter20.proxy"})
public class ProxyCircularConfig {
}

可以看到，在ProxyCircularConfig類上標註了@Configuration註解，說明ProxyCircularConfig類是案例程式的配置類。並且在ProxyCircularConfig類上使用@ComponentScan註解指定了要掃描的包名。同時，使用@EnableAsync註解開啟了非同步呼叫。

（4）新增ProxyCircularTest類

ProxyCircularTest類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.proxy.ProxyCircularTest。

public class ProxyCircularTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProxyCircularConfig.class);
        ProxyCircularBeanA proxyCircularBeanA = context.getBean(ProxyCircularBeanA.class);
        System.out.println("proxyCircularBeanA===>>>" + proxyCircularBeanA);
        System.out.println("proxyCircularBeanB===>>>" + proxyCircularBeanA.getProxyCircularBeanB());
        context.close();
    }
}

可以看到，在ProxyCircularTest類的main()方法中，建立完IOC容器後，會從IOC容器中獲取ProxyCircularBeanA型別的Bean物件，並列印ProxyCircularBeanA型別的Bean物件和依賴的ProxyCircularBeanB型別的Bean物件。

（5）執行ProxyCircularTest類

執行ProxyCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'proxyCircularBeanA': Bean with name 'proxyCircularBeanA' has been injected into other beans [proxyCircularBeanB] 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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.

從輸出的結果資訊可以看出，Spring丟擲了迴圈依賴的異常。說明Spring預設不支援基於代理物件的setter方法的迴圈依賴。

4.4 構造方法的迴圈依賴

Spring不支援基於構造方法的迴圈依賴。本節，就簡單實現一個基於構造方法的迴圈依賴，具體實現步驟如下所示。

（1）新增ConstructCircularBeanA類

ConstructCircularBeanA類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.construct.bean.ConstructCircularBeanA。

@Component
public class ConstructCircularBeanA {
    
    private ConstructCircularBeanB constructCircularBeanB;

    private ConstructCircularBeanA(ConstructCircularBeanB constructCircularBeanB){
        this.constructCircularBeanB = constructCircularBeanB;
    }

    public ConstructCircularBeanB getConstructCircularBeanB() {
        return constructCircularBeanB;
    }
}

可以看到，在ConstructCircularBeanA類中透過構造方法依賴了ConstructCircularBeanB型別的Bean物件，並提供了getConstructCircularBeanB()方法來獲取ConstructCircularBeanB型別的Bean物件。

（2）新增ConstructCircularBeanB類

ConstructCircularBeanB類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.construct.bean.ConstructCircularBeanB。

@Component
public class ConstructCircularBeanB {

    private ConstructCircularBeanA constructCircularBeanA;

    public ConstructCircularBeanB(ConstructCircularBeanA constructCircularBeanA) {
        this.constructCircularBeanA = constructCircularBeanA;
    }

    public ConstructCircularBeanA getConstructCircularBeanA() {
        return constructCircularBeanA;
    }
}

可以看到，在ConstructCircularBeanB類中透過構造方法依賴了ConstructCircularBeanA型別的Bean物件，並提供了getConstructCircularBeanA()方法來獲取ConstructCircularBeanA型別的Bean物件。

（3）新增ConstructCircularConfig類

ConstructCircularConfig類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.construct.config.ConstructCircularConfig。

@Configuration
@ComponentScan(value = {"io.binghe.spring.annotation.chapter20.construct"})
public class ConstructCircularConfig {
}

可以看到，在ConstructCircularConfig類上標註了@Configuration註解，說明ConstructCircularConfig類是案例程式的配置類，並且使用@ComponentScan註解指定了要掃描的包名。

（4）新增ConstructCircularTest類

ConstructCircularTest類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.construct.ConstructCircularTest。

public class ConstructCircularTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConstructCircularConfig.class);
        ConstructCircularBeanA constructCircularBeanA = context.getBean(ConstructCircularBeanA.class);
        System.out.println("constructCircularBeanA===>>>" + constructCircularBeanA);
        System.out.println("constructCircularBeanB===>>>" + constructCircularBeanA.getConstructCircularBeanB());
        context.close();
    }
}

可以看到，在ConstructCircularTest類的main()方法中，建立完IOC容器後，會從IOC容器中獲取ConstructCircularBeanA型別的Bean物件，並列印ConstructCircularBeanA型別的Bean物件和依賴的ConstructCircularBeanB型別的Bean物件。

（5）執行ConstructCircularTest類

執行ConstructCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'constructCircularBeanA' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanA.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanB.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/*************省略其他資訊**************/
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'constructCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanB.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/*************省略其他資訊**************/
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?

可以看到，Spring丟擲了迴圈依賴的異常，說明Spring不支援基於構造方法的迴圈依賴。

4.5 @DependsOn的迴圈依賴

@DependsOn註解主要用於指定Bean的例項化順序，Spring預設是不支援基於@DependsOn註解的迴圈依賴。本節，就實現基於@DependsOn註解的迴圈依賴。具體實現步驟如下所示。

（1）新增DependsOnCircularBeanA類

DependsOnCircularBeanA類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.dependson.bean.DependsOnCircularBeanA。

@Component
@DependsOn("dependsOnCircularBeanB")
public class DependsOnCircularBeanA {
    @Autowired
    private DependsOnCircularBeanB dependsOnCircularBeanB;

    public DependsOnCircularBeanB getDependsOnCircularBeanB() {
        return dependsOnCircularBeanB;
    }
}

可以看到，在DependsOnCircularBeanA類上不僅標註了@Component註解，也標註了@DependsOn註解指定依賴dependsOnCircularBeanB，並且在DependsOnCircularBeanA類中使用@Autowired註解注入了DependsOnCircularBeanB型別的Bean物件。同時，在DependsOnCircularBeanA類中提供了getDependsOnCircularBeanB()方法獲取DependsOnCircularBeanB型別的Bean物件。

（2）新增DependsOnCircularBeanB類

DependsOnCircularBeanB類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.dependson.bean.DependsOnCircularBeanB。

@Component
@DependsOn("dependsOnCircularBeanA")
public class DependsOnCircularBeanB {
    @Autowired
    private DependsOnCircularBeanA dependsOnCircularBeanA;

    public DependsOnCircularBeanA getDependsOnCircularBeanA() {
        return dependsOnCircularBeanA;
    }
}

可以看到，在DependsOnCircularBeanB類上不僅標註了@Component註解，也標註了@DependsOn註解指定依賴dependsOnCircularBeanA，並且在DependsOnCircularBeanB類中使用@Autowired註解注入了DependsOnCircularBeanA型別的Bean物件。同時，在DependsOnCircularBeanB類中提供了getDependsOnCircularBeanA()方法獲取DependsOnCircularBeanA型別的Bean物件。

（3）新增DependsOnCircularConfig類

DependsOnCircularConfig類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.dependson.config.DependsOnCircularConfig。

@Configuration
@ComponentScan(value = {"io.binghe.spring.annotation.chapter20.dependson"})
public class DependsOnCircularConfig {
}

可以看到，在DependsOnCircularConfig類上標註了@Configuration註解，說明DependsOnCircularConfig類是案例程式的配置類。同時，使用@ComponentScan註解指定了要掃描的包名。

（4）新增DependsOnCircularTest類

DependsOnCircularTest類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.dependson.DependsOnCircularTest。

public class DependsOnCircularTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DependsOnCircularConfig.class);
        DependsOnCircularBeanA dependsOnCircularBeanA = context.getBean(DependsOnCircularBeanA.class);
        System.out.println("dependsOnCircularBeanA===>>>" + dependsOnCircularBeanA);
        System.out.println("dependsOnCircularBeanB===>>>" + dependsOnCircularBeanA.getDependsOnCircularBeanB());
        context.close();
    }
}

可以看到，在DependsOnCircularTest類的main()方法中，建立完IOC容器後，會從IOC容器中獲取DependsOnCircularBeanA型別的Bean物件，並列印DependsOnCircularBeanA型別的Bean物件和依賴的DependsOnCircularBeanB型別的Bean物件。

（5）執行DependsOnCircularTest類

執行DependsOnCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dependsOnCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\dependson\bean\DependsOnCircularBeanB.class]: Circular depends-on relationship between 'dependsOnCircularBeanB' and 'dependsOnCircularBeanA'

從輸出的結果資訊可以看出，Spring丟擲了迴圈依賴的異常。說明Spring不支援@DependsOn註解的迴圈依賴。

4.6 單例Bean的setter迴圈依賴

Spring支援基於單例Bean的setter方法的迴圈依賴。本節，就實現基於單例Bean的setter方法的迴圈依賴案例。具體實現步驟如下所示。

（1）新增SingletonCircularBeanA類

SingletonCircularBeanA類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanA。

@Component
public class SingletonCircularBeanA {
    @Autowired
    private SingletonCircularBeanB singletonCircularBeanB;

    public SingletonCircularBeanB getSingletonCircularBeanB() {
        return singletonCircularBeanB;
    }
}

可以看到，在SingletonCircularBeanA類中依賴了SingletonCircularBeanB型別的Bean物件，並提供了getSingletonCircularBeanB()方法獲取SingletonCircularBeanB型別的Bean物件。

（2）新增SingletonCircularBeanB類

SingletonCircularBeanB類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanB。

@Component
public class SingletonCircularBeanB {
    @Autowired
    private SingletonCircularBeanA singletonCircularBeanA;

    public SingletonCircularBeanA getSingletonCircularBeanA() {
        return singletonCircularBeanA;
    }
}

可以看到，在SingletonCircularBeanB類中依賴了SingletonCircularBeanA型別的Bean物件，並提供了getSingletonCircularBeanA()方法獲取SingletonCircularBeanA型別的Bean物件。

（3）新增SingletonCircularConfig類

SingletonCircularConfig類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.singleton.config.SingletonCircularConfig。

@Configuration
@ComponentScan(value = {"io.binghe.spring.annotation.chapter20.singleton"})
public class SingletonCircularConfig {
}

可以看到，在SingletonCircularConfig類上標註了@Configuration註解，說明SingletonCircularConfig類是案例程式的配置類，並使用@ComponentScan註解指定了要掃描的包名。

（4）新增SingletonCircularTest類

SingletonCircularTest類的原始碼詳見：spring-annotation-chapter-20工程下的io.binghe.spring.annotation.chapter20.singleton.SingletonCircularTest。

public class SingletonCircularTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SingletonCircularConfig.class);
        SingletonCircularBeanA singletonCircularBeanA = context.getBean(SingletonCircularBeanA.class);
        System.out.println("singletonCircularBeanA===>>>" + singletonCircularBeanA);
        System.out.println("singletonCircularBeanB===>>>" + singletonCircularBeanA.getSingletonCircularBeanB());
        context.close();
    }
}

可以看到，在SingletonCircularTest類的main()方法中，建立完IOC容器後，會從IOC容器中獲取SingletonCircularBeanA型別的Bean物件，並列印SingletonCircularBeanA型別的Bean物件和依賴的SingletonCircularBeanB型別的Bean物件。

（5）執行SingletonCircularTest類

執行SingletonCircularTest類的main()方法，輸出的結果資訊如下所示。

singletonCircularBeanA===>>>io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanA@41e1e210
singletonCircularBeanB===>>>io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanB@be35cd9

可以看到，正確輸出了SingletonCircularBeanA型別的Bean物件和SingletonCircularBeanB型別的Bean物件。**說明Spring支援基於單例Bean的setter方法的迴圈依賴。

五、Spring迴圈依賴底層解決方案分析

Spring底層是如何解決迴圈依賴問題的?

由迴圈依賴場景的分析得知：Spring除了預設支援基於單例Bean的setter方法的迴圈依賴外，預設均不支援其他情況下的迴圈依賴。但是，如果是透過標註@Async註解生成的代理物件，則可以透過將標註了@Async註解的類排到後面載入的IOC容器中即可解決迴圈依賴的問題。

5.1 不支援單例Bean的setter迴圈依賴的特殊情況

執行4.1節中SpecialCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" java.lang.StackOverflowError

可以看到，實際丟擲的是StackOverflowError錯誤。這個錯誤資訊本質上不是Spring丟擲的，而是JVM丟擲的。根本原因其實是出在SpecialCircularBeanA和SpecialCircularBeanB兩個類的toString()方法上。

當在SpecialCircularTest類的main()方法中列印specialCircularBeanA時，預設會呼叫SpecialCircularBeanA類的toString()方法，在SpecialCircularBeanA類的toString()方法中，會拼接specialCircularBeanB物件，此時又會呼叫SpecialCircularBeanB類的toString()方法。而在SpecialCircularBeanB類的toString()方法中，又會拼接specialCircularBeanA物件，此時又會呼叫SpecialCircularBeanA類的toString()方法。在SpecialCircularBeanA類的toString()方法中，又會拼接specialCircularBeanB物件，繼而呼叫SpecialCircularBeanB類的toString()方法....如此反覆，造成了死迴圈。

簡單點說，就是在SpecialCircularBeanA類的toString()方法中呼叫了SpecialCircularBeanB類的toString()方法，在SpecialCircularBeanB類的toString()方法中呼叫了SpecialCircularBeanA類的toString()方法，造成了死迴圈，最終丟擲StackOverflowError錯誤。

5.2 不支援多例Bean的setter迴圈依賴

執行4.2節中PrototypeCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'prototypeCircularBeanA': Unsatisfied dependency expressed through field 'prototypeCircularBeanB': Error creating bean with name 'prototypeCircularBeanB': Unsatisfied dependency expressed through field 'prototypeCircularBeanA': Error creating bean with name 'prototypeCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/***************省略其他輸出資訊**************/
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'prototypeCircularBeanB': Unsatisfied dependency expressed through field 'prototypeCircularBeanA': Error creating bean with name 'prototypeCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/***************省略其他輸出資訊**************/
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'prototypeCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/***************省略其他輸出資訊**************/

Spring丟擲了迴圈依賴的異常，說明Spring不支援多例Bean的setter迴圈依賴。接下來就分析下Spring中為啥不支援多例Bean的setter迴圈依賴。具體分析步驟如下所示。

（1）解析AbstractBeanFactory類的doGetBean(String name, @Nullable Class

原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean(String name, @Nullable Class

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) {
        /**********省略其他程式碼*************/
    }
    else {
        /**********省略其他程式碼*************/
        try {
            /**********省略其他程式碼*************/
            else if (mbd.isPrototype()) {
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
  /**********省略其他程式碼*************/
        }
        catch (BeansException ex) {
            /**********省略其他程式碼*************/
        }
        finally {
           /**********省略其他程式碼*************/
        }
    }
    return adaptBeanInstance(name, beanInstance, requiredType);
}

可以看到，在多例Bean模式下，建立Bean物件之前會呼叫beforePrototypeCreation()方法，在建立Bean物件之後會呼叫afterPrototypeCreation()方法。

（2）解析AbstractBeanFactory類的beforePrototypeCreation(String beanName)方法

原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#beforePrototypeCreation(String beanName)。

protected void beforePrototypeCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    if (curVal == null) {
        this.prototypesCurrentlyInCreation.set(beanName);
    }
    else if (curVal instanceof String strValue) {
        Set<String> beanNameSet = new HashSet<>(2);
        beanNameSet.add(strValue);
        beanNameSet.add(beanName);
        this.prototypesCurrentlyInCreation.set(beanNameSet);
    }
    else {
        Set<String> beanNameSet = (Set<String>) curVal;
        beanNameSet.add(beanName);
    }
}

可以看到，Spring在建立多例Bean時，會在beforePrototypeCreation()方法中，使用prototypesCurrentlyInCreation記錄正在建立中的Bean，那prototypesCurrentlyInCreation又是個什麼鬼呢？

prototypesCurrentlyInCreation的原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#prototypesCurrentlyInCreation，如下所示。

private final ThreadLocal<Object> prototypesCurrentlyInCreation = new NamedThreadLocal<>("Prototype beans currently in creation");

也就是說，Spring在建立多例Bean時，會使用一個ThreadLocal型別的變數prototypesCurrentlyInCreation來記錄當前執行緒正在建立中的Bean。並且根據beforePrototypeCreation()方法的原始碼又可以看出，在prototypesCurrentlyInCreation變數中使用一個Set集合來儲存正在建立中的Bean。由於Set集合不存在重複物件，所以這樣就能夠保證在一個執行緒中只能有一個相同的Bean正在被建立。

（3）解析AbstractBeanFactory類的afterPrototypeCreation(String beanName)方法

原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#afterPrototypeCreation(String beanName)。

protected void afterPrototypeCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    if (curVal instanceof String) {
        this.prototypesCurrentlyInCreation.remove();
    }
    else if (curVal instanceof Set<?> beanNameSet) {
        beanNameSet.remove(beanName);
        if (beanNameSet.isEmpty()) {
            this.prototypesCurrentlyInCreation.remove();
        }
    }
}

可以看到，afterPrototypeCreation()方法中主要是對prototypesCurrentlyInCreation中儲存的Bean進行移除操作。

綜合beforePrototypeCreation()方法和afterPrototypeCreation()方法可以看出，Spring在建立多例Bean之前，會將當前執行緒正在建立的Bean存入prototypesCurrentlyInCreation中，待Bean物件例項化完成後，就從prototypesCurrentlyInCreation中移除正在建立的Bean。

（4）返回AbstractBeanFactory類的doGetBean(String name, @Nullable Class

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
    String beanName = transformedBeanName(name);
    Object beanInstance;
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
         /**********省略其他程式碼*************/
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    /**********省略其他程式碼*************/
    }
    return adaptBeanInstance(name, beanInstance, requiredType);
}

在AbstractBeanFactory類的doGetBean()方法開始的部分，會呼叫getSingleton()方法從快取中獲取單例Bean物件，首先會執行if條件進行判斷，如果獲取到的單例Bean物件為空，說明此時可能是第一次執行doGetBean()方法，也可能是建立的多例Bean。接下來會進入else分支邏輯，在else分支邏輯中，首先會判斷當前執行緒是否已經存在正在建立的Bean，如果存在，則直接丟擲BeanCurrentlyInCreationException異常。

（5）解析AbstractBeanFactory類的isPrototypeCurrentlyInCreation(String beanName)方法

原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#isPrototypeCurrentlyInCreation(String beanName)。

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    return (curVal != null && (curVal.equals(beanName) || (curVal instanceof Set<?> set && set.contains(beanName))));
}

所以，在Spring建立多例Bean時，無法解決Bean的迴圈依賴。如果在建立多例Bean的過程中，發現存在迴圈依賴，則直接丟擲BeanCurrentlyInCreationException異常。

5.3 不支援代理物件的setter迴圈依賴

執行4.3節中ProxyCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'proxyCircularBeanA': Bean with name 'proxyCircularBeanA' has been injected into other beans [proxyCircularBeanB] 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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.

從輸出的結果資訊可以看出，Spring丟擲了迴圈依賴的異常。接下來，具體分析Spring為何不支援代理物件的setter迴圈依賴。

（1）解析AbstractAutowireCapableBeanFactory類的doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法。

透過前面章節對於建立Bean的流程分析可知，無論是建立單例Bean還是建立多例Bean，Spring都會執行到AbstractAutowireCapableBeanFactory類的doCreateBean()方法中。

原始碼詳見：org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)。重點關注如下程式碼片段。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
 /********省略其他程式碼**********/ 
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    /********省略其他程式碼**********/
    if (earlySingletonExposure) {
        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<>(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) + 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 " +"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }
 /********省略其他程式碼**********/
    return exposedObject;
}

可以看到，在AbstractAutowireCapableBeanFactory類的doCreateBean()方法中，會判斷從二級快取中獲取到的物件是否等於原始物件，程式碼片段如下所示。

Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
    if (exposedObject == bean) {
        exposedObject = earlySingletonReference;
    }

此時，如果是代理物件的話，二級快取中會存放由AOP生成出來的代理物件，與原始物件不相等。所以，會丟擲BeanCurrentlyInCreationException異常。

另外，仔細觀察AbstractAutowireCapableBeanFactory類的doCreateBean()方法時，會發現如果從二級快取中獲取到的earlySingletonReference物件為空，就會直接返回，不會丟擲BeanCurrentlyInCreationException異常。由於Spring預設會按照檔案全路徑遞迴搜尋，並且會按照路徑+檔名的方式進行排序，排序靠前的Bean先被載入。所以，將標註了@Async註解的類排在後面即可解決迴圈依賴的問題。

5.4 不支援構造方法的迴圈依賴

執行4.4節中ConstructCircularTest類的main()方法，輸出的結果資訊如下所示。

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'constructCircularBeanA' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanA.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanB.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/*************省略其他資訊**************/
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'constructCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\construct\bean\ConstructCircularBeanB.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
/*************省略其他資訊**************/
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'constructCircularBeanA': Requested bean is currently in creation: Is there an unresolvable circular reference?

可以看到，Spring丟擲了迴圈依賴的異常，說明Spring不支援基於構造方法的迴圈依賴。接下來，具體分析下Spring不支援基於構造方法的迴圈依賴的原因。具體分析步驟如下所示。

（1）解析AbstractBeanFactory類的doGetBean(String name, @Nullable Class

原始碼詳見：org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean(String name, @Nullable Class

此時重點關注如下程式碼片段。

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = transformedBeanName(name);
    Object beanInstance;
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
       /********省略其他程式碼**********/
    } else {
       /********省略其他程式碼**********/
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        /********省略其他程式碼**********/
                    }
                });
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
   /********省略其他程式碼**********/
        }
        catch (BeansException ex) {
           /********省略其他程式碼**********/
        }
        finally {
            /********省略其他程式碼**********/
        }
    }
    return adaptBeanInstance(name, beanInstance, requiredType);
}

可以看到，在AbstractBeanFactory類的doGetBean()方法中，會呼叫getSingleton()方法。

（2）解析DefaultSingletonBeanRegistry類的getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法

原始碼詳見：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

可以看到，在getSingleton()方法建立Bean之前會呼叫beforeSingletonCreation()方法，在建立Bean之後會呼叫afterSingletonCreation()方法。

（3）解析DefaultSingletonBeanRegistry類的beforeSingletonCreation(String beanName)方法

原始碼詳見：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#beforeSingletonCreation(String beanName)。

protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

可以看到，在建立單例Bean之前，會將要建立的Bean的名稱新增到singletonsCurrentlyInCreation中，新增失敗，說明singletonsCurrentlyInCreation集合中已經存在當前Bean的名稱，發生了迴圈依賴，就會丟擲BeanCurrentlyInCreationException異常。那麼singletonsCurrentlyInCreation又是個什麼鬼呢?

singletonsCurrentlyInCreation的原始碼詳見：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonsCurrentlyInCreation。

private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

可以看到，singletonsCurrentlyInCreation其實就是一個Set集合。也就是說，Spring會在建立單例Bean之前，將正在建立的Bean的名稱新增到singletonsCurrentlyInCreation集合中。

（4）解析DefaultSingletonBeanRegistry類的afterSingletonCreation(String beanName)方法

原始碼詳見：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#afterSingletonCreation(String beanName)。

protected void afterSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

可以看到，在afterSingletonCreation()方法中，主要是移除singletonsCurrentlyInCreation中對應的Bean的名稱。

綜合beforeSingletonCreation()和afterSingletonCreation()兩個方法可以看出，Spring在建立單例Bean之前，會將Bean的名稱存入singletonsCurrentlyInCreation集合中，例項化Bean之後，會將Bean的名稱從singletonsCurrentlyInCreation集合中移除。並且，Spring在建立單例Bean之前，會呼叫beforeSingletonCreation()方法將要建立的Bean的名稱新增到singletonsCurrentlyInCreation中，新增失敗，說明singletonsCurrentlyInCreation集合中已經存在當前Bean的名稱，發生了迴圈依賴，就會丟擲BeanCurrentlyInCreationException異常。

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dependsOnCircularBeanB' defined in file [D:\Workspaces\2022\spring\spring-annotation-book\spring-annotation\spring-annotation-chapter-20\target\classes\io\binghe\spring\annotation\chapter20\dependson\bean\DependsOnCircularBeanB.class]: Circular depends-on relationship between 'dependsOnCircularBeanB' and 'dependsOnCircularBeanA'

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = transformedBeanName(name);
    Object beanInstance;
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
         /*********省略其他程式碼*********/
    }
    else {
        /*********省略其他程式碼*********/
        try {
            /*********省略其他程式碼*********/
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,  "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }
             /*********省略其他程式碼*********/
        }
        catch (BeansException ex) {
            /*********省略其他程式碼*********/
        }
        finally {
           /*********省略其他程式碼*********/

        }
    }
    return adaptBeanInstance(name, beanInstance, requiredType);
}

singletonCircularBeanA===>>>io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanA@41e1e210
singletonCircularBeanB===>>>io.binghe.spring.annotation.chapter20.singleton.bean.SingletonCircularBeanB@be35cd9

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
 /**********省略其他程式碼***********/
    if (earlySingletonExposure) {
       /**********省略其他程式碼***********/
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
 /**********省略其他程式碼***********/
    return exposedObject;
}

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

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 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) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}