什么是循環(huán)依賴(lài)？

顧名思義，循環(huán)依賴(lài)就是A依賴(lài)B，B又依賴(lài)A，兩者之間的依賴(lài)關(guān)系形成了一個(gè)圓環(huán)，通常是由于不正確的編碼所導(dǎo)致。Spring只能解決屬性循環(huán)依賴(lài)問(wèn)題，不能解決構(gòu)造函數(shù)循環(huán)依賴(lài)問(wèn)題，因?yàn)檫@個(gè)問(wèn)題無(wú)解。

接下來(lái)我們首先寫(xiě)一個(gè)Demo來(lái)演示Spring是如何處理屬性循環(huán)依賴(lài)問(wèn)題的。

Talk is cheap. Show me the code

第一步：定義一個(gè)類(lèi)ComponentA，其有一個(gè)私有屬性componentB。

package com.tech.ioc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 君戰(zhàn)
 * **/
@Component
public class ComponentA {

    @Autowired
    private ComponentB componentB;

    public void say(){
        componentB.say();
    }

}

第二步：定義一個(gè)類(lèi)ComponentB，其依賴(lài)ComponentA。并定義一個(gè)say方法便于打印數(shù)據(jù)。

package com.tech.ioc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
 * @author 君戰(zhàn)
 * **/
@Component
public class ComponentB {

    @Autowired
    private ComponentA componentA;

    public void say(){
        System.out.println("componentA field " + componentA);
        System.out.println(this.getClass().getName() + " -----> say()");
    }

}

第三步：重點(diǎn)，編寫(xiě)一個(gè)類(lèi)-SimpleContainer，模仿Spring底層處理循環(huán)依賴(lài)。如果理解這個(gè)代碼，再去看Spring處理循環(huán)依賴(lài)的邏輯就會(huì)很簡(jiǎn)單。

package com.tech.ioc;

import java.beans.Introspector;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 演示Spring中循環(huán)依賴(lài)是如何處理的，只是個(gè)簡(jiǎn)版，真實(shí)的Spring依賴(lài)處理遠(yuǎn)比這個(gè)復(fù)雜。
 * 但大體思路都相同。另外這個(gè)Demo很多情況都未考慮，例如線(xiàn)程安全問(wèn)題，僅供參考。
 * @author 君戰(zhàn)
 *
 * **/
public class SimpleContainer {

    /***
     * 用于存放完全初始化好的Bean，Bean處于可狀態(tài)
     * 這個(gè)Map定義和Spring中一級(jí)緩存命名一致
     * */
    private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    /***
     * 用于存放剛創(chuàng)建出來(lái)的Bean，其屬性還沒(méi)有處理，因此存放在該緩存中的Bean還不可用。
     * 這個(gè)Map定義和Spring中三級(jí)緩存命名一致
     * */
    private final Map<String, Object> singletonFactories = new HashMap<>(16);

    public static void main(String[] args) {
        SimpleContainer container = new SimpleContainer();
        ComponentA componentA = container.getBean(ComponentA.class);
        componentA.say();
    }

    public <T> T getBean(Class<T> beanClass) {
        String beanName = this.getBeanName(beanClass);
        // 首先根據(jù)beanName從緩存中獲取Bean實(shí)例
        Object bean = this.getSingleton(beanName);
        if (bean == null) {
            // 如果未獲取到Bean實(shí)例，則創(chuàng)建Bean實(shí)例
            return createBean(beanClass, beanName);
        }
        return (T) bean;
    }
    /***
     * 從一級(jí)緩存和二級(jí)緩存中根據(jù)beanName來(lái)獲取Bean實(shí)例，可能為空
     * */
    private Object getSingleton(String beanName) {
        // 首先嘗試從一級(jí)緩存中獲取
        Object instance = singletonObjects.get(beanName);
        if (instance == null) { // Spring 之所以能解決循環(huán)依賴(lài)問(wèn)題，也是靠著這個(gè)singletonFactories
            instance = singletonFactories.get(beanName);
        }
        return instance;
    }

    /***
     * 創(chuàng)建指定Class的實(shí)例，返回完全狀態(tài)的Bean(屬性可用)
     *
     * */
    private <T> T createBean(Class<T> beanClass, String beanName) {
        try {
            Constructor<T> constructor = beanClass.getDeclaredConstructor();
            T instance = constructor.newInstance();
            // 先將剛創(chuàng)建好的實(shí)例存放到三級(jí)緩存中，如果沒(méi)有這一步，Spring 也無(wú)法解決三級(jí)緩存
            singletonFactories.put(beanName, instance);
            Field[] fields = beanClass.getDeclaredFields();
            for (Field field : fields) {
                Class<?> fieldType = field.getType();
                field.setAccessible(true); 
                // 精髓是這里又調(diào)用了getBean方法，例如正在處理ComponentA.componentB屬性，
                // 執(zhí)行到這里時(shí)就會(huì)去實(shí)例化ComponentB。因?yàn)樵趃etBean方法首先去查緩存，
                // 而一級(jí)緩存和三級(jí)緩存中沒(méi)有ComponentB實(shí)例數(shù)據(jù)，所以又會(huì)調(diào)用到當(dāng)前方法，
                // 而在處理ComponentB.componentA屬性時(shí)，又去調(diào)用getBean方法去緩存中查找，
                // 因?yàn)樵谇懊嫖覀儗omponentA實(shí)例放入到了三級(jí)緩存，因此可以找到。
                // 所以ComponentB的實(shí)例化結(jié)束，方法出棧，返回到實(shí)例化ComponentA的方法棧中，
                // 這時(shí)ComponentB已經(jīng)初始化完成，因此ComponentA.componentB屬性賦值成功！
                field.set(instance, this.getBean(fieldType));
            }
            // 最后再將初始化好的Bean設(shè)置到一級(jí)緩存中。
            singletonObjects.put(beanName, instance);
            return instance;
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new IllegalArgumentException();
    }

    /**
     * 將類(lèi)名小寫(xiě)作為beanName，Spring底層實(shí)現(xiàn)和這個(gè)差不多，也是使用javaBeans的
     * {@linkplain Introspector#decapitalize(String)}
     **/
    private String getBeanName(Class<?> clazz) {
        String clazzName = clazz.getName();
        int index = clazzName.lastIndexOf(".");
        String className = clazzName.substring(index);
        return Introspector.decapitalize(className);
    }
}

如果各位同學(xué)已經(jīng)閱讀并理解上面的代碼，那么接下來(lái)我們就進(jìn)行真實(shí)的Spring處理循環(huán)依賴(lài)問(wèn)題源碼分析，相信再閱讀起來(lái)就會(huì)很容易。

底層源碼分析

分析從AbstractBeanFactory的doGetBean方法著手。可以看到在該方法首先調(diào)用transformedBeanName(其實(shí)就是處理BeanName問(wèn)題)，和我們自己寫(xiě)的getBeanName方法作用是一樣的，但Spring考慮的遠(yuǎn)比這個(gè)復(fù)雜，因?yàn)橛蠪actoryBean、別名問(wèn)題。

// AbstractBeanFactory#doGetBean
protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {

        String beanName = transformedBeanName(name);
        Object bean;

        // ?。。≈攸c(diǎn)是這里，首先從緩存中beanName來(lái)獲取對(duì)應(yīng)的Bean。
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            // 執(zhí)行到這里說(shuō)明緩存中存在指定beanName的Bean實(shí)例，getObjectForBeanInstance是用來(lái)處理獲取到的Bean是FactoryBean問(wèn)題
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        else {
            try {
                // 刪除與本次分析無(wú)關(guān)代碼....
                // 如果是單例Bean，則通過(guò)調(diào)用createBean方法進(jìn)行創(chuàng)建
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        } catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });

                }   
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }
        return (T) bean;
    }

getSingleton方法存在重載方法，這里調(diào)用的是重載的getSingleton方法，注意這里傳遞的boolean參數(shù)值為true，因?yàn)樵撝禌Q定了是否允許曝光早期Bean。

// DefaultSingletonBeanRegistry#getSingleton
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

// DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 首先從一級(jí)緩存中獲取
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            // 如果一級(jí)緩存中未獲取到，再?gòu)亩?jí)緩存中獲取
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果未從二級(jí)緩存中獲取到并且allowEarlyReference值為true(前面?zhèn)鞯臑閠rue)
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                   //Double Check
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            // 最后嘗試去三級(jí)緩存中獲取
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                // 保存到二級(jí)緩存
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                // 從三級(jí)緩存中移除
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

ok，看完Spring是如何從緩存中獲取Bean實(shí)例后，那再看看creatBean方法是如何創(chuàng)建Bean的

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    // 刪除與本次分析無(wú)關(guān)的代碼...
    try {// createBean方法底層是通過(guò)調(diào)用doCreateBean來(lái)完成Bean創(chuàng)建的。
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    } catch (Throwable ex) {
        throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

// AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 創(chuàng)建Bean實(shí)例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        // 如果允許當(dāng)前Bean早期曝光。只要Bean是單例的并且allowCircularReferences 屬性為true(默認(rèn)為true)
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            // 這里調(diào)用了addSingletonFactory方法將剛創(chuàng)建好的Bean保存到了三級(jí)緩存中。
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // 刪除與本次分析無(wú)關(guān)的代碼.....
        Object exposedObject = bean;
        try {// Bean屬性填充
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化Bean，熟知的Aware接口、InitializingBean接口.....都是在這里調(diào)用
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable ex) {

        }
        // 刪除與本次分析無(wú)關(guān)的代碼.....
        return exposedObject;
    }

先分析addSingletonFactory方法，因?yàn)樵谠摲椒ㄖ袑ean保存到了三級(jí)緩存中。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 如果一級(jí)緩存中不存在指定beanName的key
        if (!this.singletonObjects.containsKey(beanName)) {
            // 將剛創(chuàng)建好的Bean示例保存到三級(jí)緩存中
            this.singletonFactories.put(beanName, singletonFactory);
            // 從二級(jí)緩存中移除。
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

處理Bean的依賴(lài)注入是由populateBean方法完成的，但整個(gè)執(zhí)行鏈路太長(zhǎng)了，這里就不展開(kāi)講了，只說(shuō)下IoC容器在處理依賴(lài)時(shí)是如何一步一步調(diào)用到getBean方法的，這樣就和我們自己寫(xiě)的處理字段注入的邏輯對(duì)上了。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 刪除與本次分析無(wú)關(guān)代碼...
    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 遍歷所有已注冊(cè)的BeanPostProcessor接口實(shí)現(xiàn)類(lèi)，如果實(shí)現(xiàn)類(lèi)是InstantiationAwareBeanPostProcessor接口類(lèi)型的，調(diào)用其postProcessProperties方法。
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                // 刪除與本次分析無(wú)關(guān)代碼...
                pvs = pvsToUse;
            }
        }
        // 刪除與本次分析無(wú)關(guān)代碼...
    }

}

在Spring 中，@Autowired注解是由AutowiredAnnotationBeanPostProcessor類(lèi)處理，而@Resource注解是由CommonAnnotationBeanPostProcessor類(lèi)處理，這兩個(gè)類(lèi)都實(shí)現(xiàn)了InstantiationAwareBeanPostProcessor接口，都是在覆寫(xiě)的postProcessProperties方法中完成了依賴(lài)注入。這里我們就分析@Autowired注解的處理。

// AutowiredAnnotationBeanPostProcessor#postProcessProperties
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        // 根據(jù)beanName以及bean的class去查找Bean的依賴(lài)元數(shù)據(jù)-InjectionMetadata 
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        try {// 調(diào)用inject方法
            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;
    }

在InjectionMetadata的inject方法中，獲取當(dāng)前Bean所有需要處理的依賴(lài)元素(InjectedElement)，這是一個(gè)集合，遍歷該集合，調(diào)用每一個(gè)依賴(lài)注入元素的inject方法。

// InjectionMetadata#inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    // 獲取當(dāng)前Bean所有的依賴(lài)注入元素(可能是方法，也可能是字段)
    Collection<InjectedElement> checkedElements = this.checkedElements;
    Collection<InjectedElement> elementsToIterate =
            (checkedElements != null ? checkedElements : this.injectedElements);
    if (!elementsToIterate.isEmpty()) {
        // 如果當(dāng)前Bean的依賴(lài)注入項(xiàng)不為空，遍歷該依賴(lài)注入元素
        for (InjectedElement element : elementsToIterate) {
            // 調(diào)用每一個(gè)依賴(lài)注入元素的inject方法。
            element.inject(target, beanName, pvs);
        }
    }
}

在AutowiredAnnotationBeanPostProcessor類(lèi)中定義了兩個(gè)內(nèi)部類(lèi)-AutowiredFieldElement、AutowiredMethodElement繼承自InjectedElement，它們分別對(duì)應(yīng)字段注入和方法注入。

image

以大家常用的字段注入為例，在AutowiredFieldElement的inject方法中，首先判斷當(dāng)前字段是否已經(jīng)被處理過(guò)，如果已經(jīng)被處理過(guò)直接走緩存，否則調(diào)用BeanFactory的resolveDependency方法來(lái)處理依賴(lài)。

// AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        Field field = (Field) this.member;
        Object value;
        if (this.cached) {// 如果當(dāng)前字段已經(jīng)被處理過(guò)，直接從緩存中獲取
            value = resolvedCachedArgument(beanName, this.cachedFieldValue);
        } else {
            // 構(gòu)建依賴(lài)描述符
            DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
            desc.setContainingClass(bean.getClass());
            Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
            Assert.state(beanFactory != null, "No BeanFactory available");
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            try {// 調(diào)用BeanFactory的resolveDependency來(lái)解析依賴(lài)
                value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
            } catch (BeansException ex) {
                throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
            }
            // 刪除與本次分析無(wú)關(guān)代碼....
        }
        if (value != null) {
            // 通過(guò)反射來(lái)對(duì)屬性進(jìn)行賦值
            ReflectionUtils.makeAccessible(field);
            field.set(bean, value);
        }
    }
}

在DefaultListableBeanFactory實(shí)現(xiàn)的resolveDependency方法，最終還是調(diào)用doResolveDependency方法來(lái)完成依賴(lài)解析的功能。在Spring源碼中，如果存在do什么什么方法，那么該方法才是真正干活的方法。

// DefaultListableBeanFactory#resolveDependency
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        // .....
        // 如果在字段(方法)上添加了@Lazy注解，那么在這里將不會(huì)真正的去解析依賴(lài)
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                descriptor, requestingBeanName);
        if (result == null) {
            // 如果添加@Lazy注解，那么則調(diào)用doResolveDependency方法來(lái)解析依賴(lài)
            result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
        }
        return result;
}

// DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

    //.....
    try {
        // 根據(jù)名稱(chēng)以及類(lèi)型查找合適的依賴(lài)
        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
        if (matchingBeans.isEmpty()) {// 如果未找到相關(guān)依賴(lài)
            if (isRequired(descriptor)) { // 如果該依賴(lài)是必須的(@Aautowired的required屬性)，直接拋出異常
                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            return null;
        }

        String autowiredBeanName;
        Object instanceCandidate;
        // 如果查找到的依賴(lài)多于一個(gè)，例如某個(gè)接口存在多個(gè)實(shí)現(xiàn)類(lèi)，并且多個(gè)實(shí)現(xiàn)類(lèi)都注冊(cè)到IoC容器中。
        if (matchingBeans.size() > 1) {// 決定使用哪一個(gè)實(shí)現(xiàn)類(lèi)，@Primary等方式都是在這里完成
            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
            if (autowiredBeanName == null) {
                if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                    return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                } else { 
                    return null;
                }
            }
            instanceCandidate = matchingBeans.get(autowiredBeanName);
        } else {
            // We have exactly one match.
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            autowiredBeanName = entry.getKey();
            instanceCandidate = entry.getValue();
        }

        if (autowiredBeanNames != null) {
            autowiredBeanNames.add(autowiredBeanName);
        }
        // 如果查找到的依賴(lài)是某個(gè)類(lèi)的Class(通常如此)，而不是實(shí)例，
        //調(diào)用描述符的方法來(lái)根據(jù)類(lèi)型resolveCandidate方法來(lái)獲取該類(lèi)型的實(shí)例。
        if (instanceCandidate instanceof Class) {
            instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
        }
        //...
}

在依賴(lài)描述符的resolveCandidate方法中，是通過(guò)調(diào)用BeanFactory 的getBean方法來(lái)完成所依賴(lài)Bean實(shí)例的獲取。

// DependencyDescriptor#resolveCandidate
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
            throws BeansException {

    return beanFactory.getBean(beanName);
}

而在getBean方法實(shí)現(xiàn)中，依然是通過(guò)調(diào)用doGetBean方法來(lái)完成。這也和我們自己寫(xiě)的依賴(lài)處理基本一致，只不過(guò)我們自己寫(xiě)的比較簡(jiǎn)單，而Spring要考慮和處理的場(chǎng)景復(fù)雜，因此代碼比較繁雜，但大體思路都是一樣的。

// AbstractBeanFactory#getBean
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

重點(diǎn)是前面我們寫(xiě)的處理循環(huán)依賴(lài)的Demo，如果理解那個(gè)代碼，再看Spring的循環(huán)依賴(lài)處理，就會(huì)發(fā)現(xiàn)很簡(jiǎn)單。

總結(jié)

循環(huán)依賴(lài)就是指兩個(gè)Bean之間存在相互引用關(guān)系，例如A依賴(lài)B，B又依賴(lài)A，但Spring只能解決屬性循環(huán)依賴(lài)，不能解決構(gòu)造函數(shù)循環(huán)依賴(lài)，這種場(chǎng)景也無(wú)法解決。

Spring解決循環(huán)依賴(lài)的關(guān)鍵就是在處理Bean的屬性依賴(lài)時(shí)，先將Bean存到三級(jí)緩存中，當(dāng)存在循環(huán)依賴(lài)時(shí)，從三級(jí)緩存中獲取到相關(guān)Bean，然后從三級(jí)緩存中移除，存入到二級(jí)緩存中。
看懂了，其實(shí)循環(huán)依賴(lài)就這樣簡(jiǎn)單，最后點(diǎn)擊這里即可領(lǐng)取Java架構(gòu)大禮包哦?。?！