久久精品优质资源一區,成人77夜色视频

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

Spring循環(huán)依賴那些事兒（含Spring詳細流程圖）

背景

1、循環(huán)依賴異常信息

應用時間時間久
應用多人同時并行開發(fā)
應用保證迭代進度

經常出現(xiàn)啟動時出現(xiàn)循環(huán)依賴異常

創(chuàng)新互聯(lián)于2013年開始，先為義馬等服務建站，義馬等地企業(yè)，進行企業(yè)商務咨詢服務。為義馬企業(yè)網(wǎng)站制作PC+手機+微官網(wǎng)三網(wǎng)同步一站式服務解決您的所有建站問題。

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'taskPunchEvent': Injection of resource dependencies failed; nested exception is org.
springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'playContentService': Bean with name 'playContentService' has been injected into other be
ans [toVoConvertor] 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. Thi
s is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
  at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessProperties(CommonAnnotationBeanPostProcessor.java:325)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1404)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:592)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:515)
  at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320)
  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)
  at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:277)
  at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1255)
  at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1175)
  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:595)
  ... 40 more
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'playContentService': Bean with name 'playContentService' has been injecte
d into other beans [toVoConvertor] 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 o
f the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:622)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:515)
  at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320)
  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:204)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.resolveBeanByName(AbstractAutowireCapableBeanFactory.java:452)
  at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:527)
  at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:497)
  at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:637)
  at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:180)
  at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90)
  at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessProperties(CommonAnnotationBeanPostProcessor.java:322)
  ... 51 more

2、依賴關系

先不關注其他不規(guī)范問題，看現(xiàn)象

3、涉及基礎知識

Spring bean 創(chuàng)建流程
Dynamic Proxy 動態(tài)代理
Spring-AOP 原理

問題

1、什么是循環(huán)依賴？

2、為什么會產生循環(huán)依賴？

3、循環(huán)依賴有哪些場景？

4、Spring如何解決循環(huán)依賴的？

5、Spring為什么使用三級緩存？

6、Spring支持AOP循環(huán)依賴，為何還存在循環(huán)依賴異常？

7、Spring不支持的循環(huán)依賴場景及如何解決？

注：Spring啟動流程與Bean創(chuàng)建初始化流程如不熟悉，自行補習，篇幅原因此處不做介紹

Spring循環(huán)依賴

1、什么是循環(huán)依賴

2、核心概念

BeanDefinition：spring核心bean的配置信息
Spring Bean：spring管理的已經初始化好以后的可使用的實例

首先，通過spring通過掃描各種注解 @Compoent、@Service、@Configuration等等把需要交給spring管理的bean初始化成 BeanDefinition 的列表

然后，根據(jù) BeanDefinition 創(chuàng)建spring bean的實例

Java Bean：Java簡單通過構造函數(shù)創(chuàng)建的對象
Spring通過推斷構造方法后，通過反射調用構造函數(shù)創(chuàng)建的對象

3、什么情況下出現(xiàn)循環(huán)依賴

并非使用者手動去getBean才會加載并初始化，而是框架啟動時進行加載

Spring創(chuàng)建Bean - #DefaultListableBeanFactory#preInstantiateSingletons


@Override
public void preInstantiateSingletons() throws BeansException {
    
    //......
    
    List beanNames = new ArrayList<>(this.beanDefinitionNames);


    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                //FactoryBean接口處理
                ......
            }
            else {
                //正常Bean的加載入口
                getBean(beanName);
            }
        }
    }
    
    //......
}

4、循環(huán)依賴場景

構造器內的循環(huán)依賴

注入的好處很明顯，如果容器中不存在或者存在多個實現(xiàn)時，可以從容處理。

強依賴，先有雞還是先有蛋問題暫無解，此依賴方式Spring不支持，除非自身實現(xiàn)代理加延遲注入，這種方式很難解決，除非實現(xiàn)類似于lazy生成代理方式進行解耦來實現(xiàn)注入，Spring沒有支持可能因為此種注入場景都可以用其他方式代替且場景極少。

弱依賴，spring 4.3之后增加 ObjectProvider 來處理

//構造器循環(huán)依賴示例


public class StudentA {
 
    private StudentB studentB ; 


    public StudentA(StudentB studentB) {
        this.studentB = studentB;
    }
}


public class StudentB {
 
    private StudentA studentA ;
    
    public StudentB(StudentA studentA) {
        this.studentA = studentA;
    }
}

setter方式單例，默認方式
setter方式原型，prototype
對于“prototype”作用域Bean，Spring容器不進行緩存，因此無法提前暴露一個創(chuàng)建中的Bean。
field屬性循環(huán)依賴
最常用，此場景是通過反射注入，以下為@Autowire 注入代碼，@Resource省略AutowiredAnnotationBeanPostProcessor#postProcessProperties

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        //屬性注入
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

5、三級緩存解決循環(huán)依賴

(1)一級緩存

DefaultSingletonBeanRegistry

private final Map singletonObjects = new ConcurrentHashMap<>(256);

最基礎的單例緩存
限制 bean 在 beanFactory 中只存一份，即實現(xiàn) singleton scope

(2)二級緩存

二級緩存(未初始化未填充屬性提前暴露的Bean)

private final Map earlySingletonObjects = new HashMap<>(16);

看名字應該就能猜到，緩存earlySingletonBean，與三級緩存配合使用的
需要注意：

在沒有AOP場景時是可以的，每次earlySingletonObjects.get()換成去三級緩存取就可以，存在問題
存在AOP場景時
因此，讓使用者去做重復性判斷是不可控的，很容易出現(xiàn)問題，于是引入了第二級緩存，當調用三級緩存里的對象工廠的getObject方法之后，getEarlyBeanReference 就會把返回值放入二級緩存，刪除三級緩存，后續(xù)其他依賴該對象的Bean獲取的都是同一個earlyBean，保證singleton原則。
每次都調用 getEarlyBeanReference，即使返回對象都一致，也浪費不必要時間
如果使用者在 getEarlyBeanReference 時直接 new XXX()，則對象又不一致，無法保證 singleton，所以需要使用者熟悉這塊原理，并且自身維護，并且暴露內部實現(xiàn)細節(jié)
每次都調用 getEarlyBeanReference 返回代理對象都不一致，無法保證 singleton
如果沒有此緩存，可不可以解決循環(huán)依賴問題？

(3)三級緩存

三級緩存(Bean創(chuàng)建時提供代理機會的Bean工廠緩存)

private final Map> singletonFactories = new HashMap<>(16);

所以二級緩存和三級緩存是組合，不要拆成兩個獨立的東西去理解
基于這種設計，沒有發(fā)生循環(huán)依賴的bean就是正常的創(chuàng)建流程
相互引用的bean 會觸發(fā)鏈路中最初結點放入三級緩存內容，調用 getEarlyBeanReference 返回相應對象

6、Spring為何不使用一級、二級緩存解決循環(huán)依賴

循環(huán)依賴產生在Bean創(chuàng)建時

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    
    BeanWrapper instanceWrapper = null;


    if (instanceWrapper == null) {
        //創(chuàng)建Bean
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
        
    .....
    
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }


    //填充Bean依賴與Bean的初始化
    Object exposedObject = bean;
    try {
        //填充依賴的bean實例
        populateBean(beanName, mbd, instanceWrapper);
        //初始化---注意！注意！注意！此方法中可能調用 BeanPostProcessor
        //的applyBeanPostProcessorsAfterInitialization時可能會返回代理對象，如果代理途徑與創(chuàng)建時代理方式不同則也會產生不同代理對象
        //從而產生循環(huán)依賴中對象不一致情況
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }


    //如果存在循環(huán)依賴，則保證最開始創(chuàng)建的Bean需要是循環(huán)依賴 getEarlyBeanReference觸發(fā)生成的bean
    //因為getEarlyBeanReference 可能返回的是代理類，因為singleton必須全局唯一
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        //只有真正存在循環(huán)依賴時，才會觸發(fā) getEarlyBeanReference調用產生EarlyBean
        //未存在循環(huán)依賴，則getEarlyBeanReference不觸發(fā)，earlySingletonReference為null，返回exposedObject即可
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                ......
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            "] 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.");
                }
            }
        }
    }
    return exposedObject;
}

三級緩存獲取Bean

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //一級緩存(單例池)獲取Bean
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            //二級緩存獲取(提前暴露不完全)Bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //三級緩存Bean的創(chuàng)建工廠獲取bean(可提前被代理)
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

SmartInstantiationAwareBeanPostProcessor重點 -> APC之父

//提供提前創(chuàng)建并返回代理的工廠singletonFactory.getObject()執(zhí)行的是個回調
//addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));


protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            //getEarlyBeanReference是SmartInstantiationAwareBeanPostProcessor接口定義方法，
            //此方法很關鍵(構造函數(shù)推斷也在此定義)
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

7、Spring支持動態(tài)代理循環(huán)依賴，為何還會出循環(huán)依賴異常？

(1)、相互依賴的Bean只有需要AOP或者動態(tài)代理時才有可能出現(xiàn)循環(huán)依賴異常

正常情況原始Spring Bean無論怎樣相互依賴都沒有問題，Spring完全可以處理這種場景
絕大多數(shù)存在AOP場景也都是支持的，Spring支持的
只有相互依賴場景下某些Bean需要被動態(tài)代理時偶爾會出現(xiàn)循環(huán)依賴異常問題，以下解釋異常場景：

通俗解釋(省略很多細節(jié))：A -> B -> C -> A

Spring 啟動開始創(chuàng)建 A，doCreateBean()中對A進行屬性填充populateBean()時需要發(fā)現(xiàn)依賴B對象，此時A還沒有進行初始化，把A原始對象包裝成SingletonFactory 放入三級緩存。
A依賴B，因此doCreateBean()會創(chuàng)建B，并對B進行屬性填空populateBean()時需要發(fā)現(xiàn)依賴C對象。
C依賴A，因此doCreateBean()會創(chuàng)建C，并對C進行屬性填空populateBean()時需要發(fā)現(xiàn)依賴A對象。
3.1. 此時去一級緩存獲取A，因為A前邊并沒有填充與初始化完成，因此在一級緩存中不存在；3.2. 去二級緩存取A，因為A前邊并沒有填充與初始化完成，因此在二級緩存中不存在；3.3. 去三級緩存取A，第一步中把A封裝成SingletonFactory放入三級緩存的，因此三級緩存中可以獲取到A的對象3.3.1. 此時獲取的A如果有必要會對A進行動態(tài)代理，返回代理對象；3.3.2. 否則不需要代理則返回未填充、未初始化的原始對象A；
3.4. 獲取到A對象，注入到C中，接著初始化C，返回C對象；
C對象返回，注入到B中，接著初始化B，返回B對象；
B對象返回，注入到A中，接著初始化A，問題就在這兒：
5.1. 如接下來初始化A無需被代理5.1.1. exposedObject返回是A原始對象，此時與C中被注入A都是原始Bean，完美；
5.2. 如接下來初始化A需要被代理：
5.2.1. APC根據(jù)緩存檢查之前創(chuàng)建A時是否被代理過，如已被代理，直接返回原始對象，與A原始一致，完美；5.2.2. 但是，如此時A初始化過程中有獨特的其他BeanPostProcessor，對A的代理方式有單獨處理，則被代理后的proxy2與原始Bean、被注入到C中的A的Proxy均不再一致，拋出異常；
總結重點：

6.1. 最終原因就是提前暴露的已經注入到C中的A(無論是否被代理)與后來經過初始化后被代理的A(proxy2)不再是同一個Bean；

6.2. 因為Spring管理Bean默認是Singleton的，現(xiàn)在出現(xiàn)了兩個bean，默認情況下無法決斷，因此就拋出了異常。

(2)、各別注解使用不當

@Respository

處理器 PersistenceExceptionTranslationPostProcessor#postProcessAfterInitialization
被 @Respository注解的類在Spring啟動初始化時存在循環(huán)依賴鏈路中，如果此時Spring中開啟了AOP，則必拋出循環(huán)依賴異常
所以DAO層使用時，最好不要引入外部業(yè)務邏輯，業(yè)務邏輯可以提取到Manager、Service層等中，保持DAO純凈
案例分析：見第四節(jié)

@Asyn
處理器 AsyncAnnotationBeanPostProcessor#postProcessAfterInitialization
被 @Asyn注解的類在Spring啟動初始化時存在循環(huán)依賴鏈路中，如果此時Spring中開啟了AOP，則必拋出循環(huán)依賴異常
以上等注解的類使用不當都比較容易出現(xiàn)循環(huán)依賴，這兩個注解同一個父類，造成循環(huán)依賴原理一樣
AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization

(3)、存在多個AutoProxyCreator(APC)，出現(xiàn)多層代理

spring默認保證一個容器中只能有一個Aop的APC，如過手動添加或者自定義會出現(xiàn)多個APC情況

InfrastructureAdvisorAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator

三者有就按照優(yōu)先級覆蓋，否則就注冊一個，因此始終就只會有一個APC

AopConfigUtils

static {

    APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);

    APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);

    APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);

}




private static BeanDefinition registerOrEscalateApcAsRequired(

            Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {




    

    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {

        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);

        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {

            //因為三個APC存在能力父子關系，按照指定注冊的APC自動調整優(yōu)先級，從而保證只存在一個APC

            //如未指定APC，則默認為InfrastructureAdvisorAutoProxyCreator

            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());

            int requiredPriority = findPriorityForClass(cls);

            if (currentPriority < requiredPriority) {

                apcDefinition.setBeanClassName(cls.getName());

            }

        }

        return null;

    }




    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);

    beanDefinition.setSource(source);

    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);

    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);

    return beanDefinition;

}

存在多個APC時，如存在循環(huán)依賴，此時觸發(fā)之前放入三級緩存邏輯

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

從而觸發(fā)多個APC的 getEarlyBeanReference

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {

    Object exposedObject = bean;

    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

        //此時如存在多個APC,則依次執(zhí)行 getEarlyBeanReference 返回多層代理對象

        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {

            exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);

        }

    }

    return exposedObject;

}

最終proxy2會被注入到依賴的Bean中，即例如：A-proxy2 注入到 B中

存在多個多層代理情況，getEarlyBeanReference 沒有問題，但是執(zhí)行到初始化時

@Override

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {

    if (bean != null) {

        //注意這個Bean可是原始對象，每個APC都緩存自身代理過的類，但是存在多個APC時，后續(xù)的APC緩存的確是代理類的代理

        //即如第二個APC是BeanNameAutoProxyCreator，其緩存的可是 proxy1的class，原始類在此APC是沒被代理過的，

        //因此此時會對原始類進行二次代理，產生Proxy3

        Object cacheKey = getCacheKey(bean.getClass(), beanName);

        if (this.earlyProxyReferences.remove(cacheKey) != bean) {

            return wrapIfNecessary(bean, beanName, cacheKey);

        }

    }

    return bean;

}







//視線返回本次循環(huán)依賴最初實例化的結點:A->B->C->A，則此處為A的創(chuàng)建流程

//此時A 通過 getEarlyBeanReference生成A ->proxy2注入到C中，

//C直接實例創(chuàng)建不會觸發(fā)getEarlyBeanReference，注入到B中

//B直接實例創(chuàng)建不會觸發(fā)getEarlyBeanReference，注入到A中

//A依賴處理完畢，繼續(xù)初始化 initializeBean流程 -> postProcessAfterInitialization，返回 proxy3

if (earlySingletonExposure) {

    //此時獲取到的代理類是 proxy2，即已經注入到依賴類C中的代理，因此不為null

    Object earlySingletonReference = getSingleton(beanName, false);

    if (earlySingletonReference != null) {

        //多APC時,exposedObject 在之前initializeBean -> postProcessAfterInitialization作用下返回proxy3

        //proxy3 != bean 不一致，違反了singletion原則，因此會拋出循環(huán)依賴異常

        if (exposedObject == bean) {

            exposedObject = earlySingletonReference;

        }

        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

            ......

            if (!actualDependentBeans.isEmpty()) {

                throw new BeanCurrentlyInCreationException(beanName,

                                                           "Bean with name '" + beanName + "' has been injected into other beans [" +

                                                           StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +

                                                           "] 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 " +

                                                           "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

            }

        }

    }

}

8、正常AOP代理為何沒問

SmartInstantiationAwareBeanPostProcessor

@Override

public Object getEarlyBeanReference(Object bean, String beanName) {

    Object cacheKey = getCacheKey(bean.getClass(), beanName);

    this.earlyProxyReferences.put(cacheKey, bean);

    return wrapIfNecessary(bean, beanName, cacheKey);

}







//提前通過singletonFactory.getObject()創(chuàng)建的代理緩存起來以后，這里如果再次判斷需要代理，

//緩存中存在已被代理則直接返回原始bean，無需再次代理，后續(xù)直接獲取earlySingletonReference，

//因此前后代理出來的對象是一致的

@Override

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {

    if (bean != null) {

        Object cacheKey = getCacheKey(bean.getClass(), beanName);

        if (this.earlyProxyReferences.remove(cacheKey) != bean) {

            return wrapIfNecessary(bean, beanName, cacheKey);

        }

    }

    return bean;

}

解決方案

1、無需代理場景使用原始對象

原始對象相互注入沒有問題，檢查不許要生成代理的類

2、@lazy解耦

原理是發(fā)現(xiàn)有@lazy注解的依賴為其生成代理類，依賴代理類，從而實現(xiàn)了解耦
@Lazy 用來標識類是否需要延遲加載；
@Lazy 可以作用在類上、方法上、構造器上、方法參數(shù)上、成員變量中；
@Lazy 作用于類上時，通常與 @Component 及其衍生注解配合使用；
@Lazy 注解作用于方法上時，通常與 @Bean 注解配合使用；

DefaultListableBeanFactory#resolveDependency

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
                                @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {


    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    if (Optional.class == descriptor.getDependencyType()) {
        return createOptionalDependency(descriptor, requestingBeanName);
    }
    ......
    else {
        //處理@lazy
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
        if (result == null) {
            result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}


ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary
public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
    return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
}


ContextAnnotationAutowireCandidateResolver#isLazy
//是否為@lazy，如果為@lazy則創(chuàng)建依賴代理
protected boolean isLazy(DependencyDescriptor descriptor) {
    for (Annotation ann : descriptor.getAnnotations()) {
        Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
        if (lazy != null && lazy.value()) {
            return true;
        }
    }
    .......
}

3、抽取公共邏輯

業(yè)務層面重構，不再相互依賴而是依賴公共模塊，并且各個對外業(yè)務與內部接口拆分

案例(可直接運行)

1、@Repository案例分析

import org.junit.Test;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
/**
 * @author: Superizer
 */
@Component
public class MainSpringCircularDependencyTester
{
    @Test
    public void springCircularDependencyTest()
    {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringCircularDependencyConfig.class);
        X x = ac.getBean(X.class);
        System.out.println("Spring bean X =" + x.getClass().getName());
        x.display();
        Y y = ac.getBean(Y.class);
        System.out.println("Spring bean Y =" + y.getClass().getName());
        y.display();
        Z z = ac.getBean(Z.class);
        System.out.println("Spring bean Z =" + z.getClass().getName());
        z.display();
        System.out.println("******************Main********************");
    }
    @Configuration
    @ComponentScan("com.myself.demo.spring.v5.circular.dependency")
//  @EnableAspectJAutoProxy
    @ConditionalOnClass(PersistenceExceptionTranslationPostProcessor.class)
    static class SpringCircularDependencyConfig{
        @Bean
        @ConditionalOnMissingBean
        @ConditionalOnProperty(prefix = "spring.dao.exceptiontranslation", name = "enabled",
                matchIfMissing = true)
        public static PersistenceExceptionTranslationPostProcessor
        persistenceExceptionTranslationPostProcessor(Environment environment) {
            PersistenceExceptionTranslationPostProcessor postProcessor = new PersistenceExceptionTranslationPostProcessor();
            boolean proxyTargetClass = environment.getProperty(
                    "spring.aop.proxy-target-class", Boolean.class, Boolean.TRUE);
            postProcessor.setProxyTargetClass(proxyTargetClass);
            return postProcessor;
        }
    }
    abstract static class A {
        public abstract A injectSources();
        public abstract A self();
        public void display(){
            System.out.println("injectSources:" + injectSources().getClass().getName());
            System.out.println("*******************************************************");
        }
    }
    //X、Y、Z 只要循環(huán)依賴中第一個類X有注解@Repository，就會出現(xiàn)循環(huán)依賴異常
    //執(zhí)行X的singletonFactory.getObject()返回的原對象，但是后邊初始化時
    //執(zhí)行到PersistenceExceptionTranslationPostProcessor時單獨創(chuàng)建代理邏輯返回的是代理類
    //exposedObject = initializeBean(beanName, exposedObject, mbd);
    @Repository
//  @Component
    static class X  extends A{
        @Resource
        private Y y;
        @Override
        public Y injectSources()
        {
            return y;
        }
        @Override
        public X self() {
            return this;
        }
    }
    @Component
//  @Repository
    static class Y extends A{
        @Resource
        private Z z;
        @Override
        public Z injectSources() {
            return z;
        }
        @Override
        public Y self()
        {
            return this;
        }
    }
    @Component
//  @Repository
    static class Z extends A{
        @Resource
        private X x;
        @Override
        public X injectSources()
        {
            return x;
        }
        @Override
        public Z self()
        {
            return this;
        }
    }
}

2、多AutoProxyCreator場景

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.junit.Test;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.aop.support.AbstractExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Arrays;
/**
 * @author: Superizer
 * Copyright (C) 2021
 * All rights reserved
 */
@Component
public class MainSpringCircularDependencyV2Tester
{
    @Test
    public void circularDependencyV2Tester()
    {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringCircularDependencyConfig.class);
        A a = ac.getBean(A.class);
        System.out.println("Spring bean A =" + a.getClass().getName());
        a.display();
        B y = ac.getBean(B.class);
        System.out.println("Spring bean B =" + y.getClass().getName());
        y.display();
        C z = ac.getBean(C.class);
        System.out.println("Spring bean C =" + z.getClass().getName());
        z.display();
        System.out.println("******************Main********************");
    }
    @Configuration
    @ComponentScan("com.myself.demo.spring.v5.circular.dependency.v2")
    @EnableAspectJAutoProxy
    static class SpringCircularDependencyConfig {
        @Bean
        public DefaultPointcutAdvisor defaultPointcutAdvisor() {
            DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
            Pointcut pointcut = new AbstractExpressionPointcut() {
                @Override
                public ClassFilter getClassFilter() {
                    return (tmp) -> {
                        String name = tmp.getName();
                        if(name.equals(A.class.getName())) {
                            return true;
                        }
                        return false;
                    };
                }
                @Override
                public MethodMatcher getMethodMatcher() {
                    return MethodMatcher.TRUE;
                }
            };
            advisor.setPointcut(pointcut);
            advisor.setAdvice(new SpringAopAroundMethod());
            advisor.setOrder(0);
            return advisor;
        }
        @Bean
        public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
            BeanNameAutoProxyCreator apc = new BeanNameAutoProxyCreator();
            apc.setBeanNames("a");
            apc.setOrder(-1);
            apc.setProxyTargetClass(true);
            return apc;
        }
    }
    abstract static class G {
        public abstract G injectSources();
        public abstract G self();
        public void display(){
            System.out.println("injectSources:" + injectSources().getClass().getName());
            System.out.println("*******************************************************");
        }
    }
    @Component(value = "a")
    static class A  extends G {
        @Resource
        private B b;
        @Override
        public B injectSources()
        {
            return b;
        }
        @Override
        public A self() {
            return this;
        }
    }
    @Component
    static class B extends G {
        @Resource
        private C c;
        @Override
        public C injectSources() {
            return c;
        }
        @Override
        public B self()
        {
            return this;
        }
    }
    @Component
    static class C extends G {
        @Resource
        private A a;
        @Override
        public A injectSources()
        {
            return a;
        }
        @Override
        public C self()
        {
            return this;
        }
    }
    static class SpringAopAroundMethod implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable {
            System.out.println("Aop Before method!");
            try {
                Object result = methodInvocation.proceed();
                System.out.println("Aop after method!");
                return result;
            } catch (IllegalArgumentException e) {
                System.out.println("Aop throw exception!");
                throw e;
            }
        }
    }
}

總結

出現(xiàn)循環(huán)依賴其實反映代碼結構設計上的問題，理論上應當將循環(huán)依賴進行分層，抽取公共部分，然后由各個功能類再去依賴公共部分。

但是在復雜代碼中，各個service、manager類互相調用太多，總會一不小心出現(xiàn)一些類之間的循環(huán)依賴的問題。可有時候我們又發(fā)現(xiàn)在用Spring進行依賴注入時，雖然Bean之間有循環(huán)依賴，但是代碼本身卻大概率能很正常的work，似乎也沒有任何bug。

很多敏感的同學心里肯定有些犯嘀咕，循環(huán)依賴這種觸犯因果律的事情怎么能發(fā)生呢？沒錯，這一切其實都并不是那么理所當然。Spring已經為我們背負了太多，但絕不是偷懶的借口，還是應該規(guī)范設計，規(guī)范代碼，盡量做到從根本上避免這種循環(huán)依賴的發(fā)生。

Spring流程圖

當前名稱：Spring循環(huán)依賴那些事兒（含Spring詳細流程圖）
網(wǎng)站URL：http://www.5511xx.com/article/djgejge.html

日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

新聞中心

背景

1、循環(huán)依賴異常信息

2、依賴關系

3、涉及基礎知識

問題

1、什么是循環(huán)依賴？

2、為什么會產生循環(huán)依賴？

3、循環(huán)依賴有哪些場景？

4、Spring如何解決循環(huán)依賴的？

5、Spring為什么使用三級緩存？

6、Spring支持AOP循環(huán)依賴，為何還存在循環(huán)依賴異常？

7、Spring不支持的循環(huán)依賴場景及如何解決？

Spring循環(huán)依賴

1、什么是循環(huán)依賴

2、核心概念

3、什么情況下出現(xiàn)循環(huán)依賴

4、循環(huán)依賴場景

5、三級緩存解決循環(huán)依賴

(1)一級緩存

(2)二級緩存

(3)三級緩存

6、Spring為何不使用一級、二級緩存解決循環(huán)依賴

7、Spring支持動態(tài)代理循環(huán)依賴，為何還會出循環(huán)依賴異常？

(1)、相互依賴的Bean只有需要AOP或者動態(tài)代理時才有可能出現(xiàn)循環(huán)依賴異常

(2)、各別注解使用不當

(3)、存在多個AutoProxyCreator(APC)，出現(xiàn)多層代理

8、正常AOP代理為何沒問

解決方案

1、無需代理場景使用原始對象

2、@lazy解耦

3、抽取公共邏輯

案例(可直接運行)

1、@Repository案例分析

2、多AutoProxyCreator場景

總結

Spring流程圖

其他資訊

新聞中心

背景

1、循環(huán)依賴異常信息

2、依賴關系

3、涉及基礎知識

問題

1、什么是循環(huán)依賴？

2、為什么會產生循環(huán)依賴？

3、循環(huán)依賴有哪些場景？

4、Spring如何解決循環(huán)依賴的？

5、Spring為什么使用三級緩存？

6、Spring支持AOP循環(huán)依賴，為何還存在循環(huán)依賴異常？

7、Spring不支持的循環(huán)依賴場景及如何解決？

Spring循環(huán)依賴

1、什么是循環(huán)依賴

2、核心概念

3、什么情況下出現(xiàn)循環(huán)依賴

4、循環(huán)依賴場景

5、三級緩存解決循環(huán)依賴

(1)一級緩存

(2)二級緩存

(3)三級緩存

6、Spring為何不使用一級、二級緩存解決循環(huán)依賴

7、Spring支持動態(tài)代理循環(huán)依賴，為何還會出循環(huán)依賴異常？

(1)、相互依賴的Bean只有需要AOP或者動態(tài)代理時才有可能出現(xiàn)循環(huán)依賴異常

(2)、各別注解使用不當

(3)、存在多個AutoProxyCreator(APC)，出現(xiàn)多層代理

8、正常AOP代理為何沒問

解決方案

1、無需代理場景使用原始對象

2、@lazy解耦

3、抽取公共邏輯

案例(可直接運行)

1、@Repository案例分析

2、多AutoProxyCreator場景

總結

Spring流程圖

其他資訊

1、循環(huán)依賴異常信息

2、依賴關系

3、涉及基礎知識

1、什么是循環(huán)依賴？

2、為什么會產生循環(huán)依賴？

3、循環(huán)依賴有哪些場景？

4、Spring如何解決循環(huán)依賴的？

5、Spring為什么使用三級緩存？

6、Spring支持AOP循環(huán)依賴，為何還存在循環(huán)依賴異常？

7、Spring不支持的循環(huán)依賴場景及如何解決？

2、核心概念

3、什么情況下出現(xiàn)循環(huán)依賴

4、循環(huán)依賴場景

6、Spring為何不使用一級、二級緩存解決循環(huán)依賴

7、Spring支持動態(tài)代理循環(huán)依賴，為何還會出循環(huán)依賴異常？

(1)、相互依賴的Bean只有需要AOP或者動態(tài)代理時才有可能出現(xiàn)循環(huán)依賴異常

(2)、各別注解使用不當

(3)、存在多個AutoProxyCreator(APC)，出現(xiàn)多層代理

8、正常AOP代理為何沒問

1、無需代理場景使用原始對象

2、@lazy解耦

3、抽取公共邏輯

1、@Repository案例分析

2、多AutoProxyCreator場景