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

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
SpringBeanIOC、AOP循環(huán)依賴解讀

本文轉(zhuǎn)載自微信公眾號「bugstack蟲洞?！?，作者小傅哥  。轉(zhuǎn)載本文請聯(lián)系bugstack蟲洞棧公眾號。

成都創(chuàng)新互聯(lián)專注為客戶提供全方位的互聯(lián)網(wǎng)綜合服務(wù)，包含不限于網(wǎng)站制作、網(wǎng)站設(shè)計、芙蓉網(wǎng)絡(luò)推廣、重慶小程序開發(fā)、芙蓉網(wǎng)絡(luò)營銷、芙蓉企業(yè)策劃、芙蓉品牌公關(guān)、搜索引擎seo、人物專訪、企業(yè)宣傳片、企業(yè)代運營等，從售前售中售后，我們都將竭誠為您服務(wù)，您的肯定，是我們最大的嘉獎；成都創(chuàng)新互聯(lián)為所有大學(xué)生創(chuàng)業(yè)者提供芙蓉建站搭建服務(wù)，24小時服務(wù)熱線：18980820575，官方網(wǎng)址：www.cdcxhl.com

目錄

  • 一、前言
  • 二、面試題
  • 三、什么是循環(huán)依賴?
    • 1. 問題描述
    • 2. 問題體現(xiàn)
    • 3. 問題處理
  • 四、源碼分析
    • 1. 說說細節(jié)
    • 2. 處理過程
    • 3. 依賴解析
  • 五、總結(jié)
  • 六、系列推薦

一、前言

延遲滿足能給你帶來什么?

大學(xué)有四年時間，但幾乎所有人都是臨近畢業(yè)才發(fā)現(xiàn)找一份好工作費勁，尤其是我能非常熟悉的軟件開發(fā)行業(yè)，即使是畢業(yè)了還需要額外花錢到培訓(xùn)機構(gòu)，在學(xué)一遍編程技術(shù)才能出去找工作。好像在校這幾年壓根就沒學(xué)到什么!

就我個人而言可能是因為上學(xué)期間喜歡編程，也從師哥、師姐那里聽到一些關(guān)于畢業(yè)后找工作的不容易，也了解了一些社會上對程序員開發(fā)技能的要求級別。也就是得到了這些消息，又加上自己樂于折騰，我給自己定了一個每天都能完成的小目標：

紅塵世界幾個王，我自不服迎頭上。

日敲代碼兩百行，沖進世界五百強。

哈哈哈，就這么每天兩百行代碼，一個月就是6千行，一年就是6萬行，三年后開始實習(xí)就有18萬行，一個應(yīng)屆實習(xí)生有將近20萬行代碼的敲擊量，幾乎已經(jīng)可以非常熟練的完成各類簡單的工作，在加上實習(xí)中對整個項目流程真正的斷鏈后，找一個正經(jīng)的開發(fā)工作，還是很容易的。

而這時候找工作的容易，就來自于你一直以來的學(xué)習(xí)和沉淀，但如果你沒經(jīng)過這些努力，可能等畢業(yè)后就會變得非?；艁y，最后沒辦法，只能去一些機構(gòu)再學(xué)習(xí)一遍。

二、面試題

謝飛機，小記!，以前感覺Spring沒啥，看過一篇getBean，我的天!

謝飛機：面試官，最近我看了 Spring 的 getBean 發(fā)現(xiàn)這里好多東西，還有一個是要解決循環(huán)依賴的，這玩意面試有啥要問的嗎?

面試官：有哇，Spring 是如何解決循環(huán)依賴的?

謝飛機：嗯，通過三級緩存提前暴露對象解決的。

面試官：可以哈，那這三個緩存里都存放了什么樣的對象信息呢?

謝飛機：一級緩存存放的是完整對象，也叫成品對象。二級緩存存放的是半成品對象，就是那些屬性還沒賦值的對象。三級緩存存放的是 ObjectFactory 類型的 lambda 表達式，就是這用于處理 AOP 循環(huán)依賴的。

面試官：可以呀，謝飛機有所準備嘛!那如果沒有三級緩存，只有二級或者一級，能解決循環(huán)依賴嗎?

謝飛機：其實我看過資料了，可以解決，只不過 Spring 要保證幾個事情，只有一級緩存處理流程沒法拆分，復(fù)雜度也會增加，同時半成品對象可能會有空指針異常。而將半成品與成品對象分開，處理起來也更加優(yōu)雅、簡單、易擴展。另外 Spring 的兩大特性中不僅有 IOC 還有 AOP，也就是基于字節(jié)碼增強后的方法，該存放到哪，而三級緩存最主要，要解決的循環(huán)依賴就是對 AOP 的處理，但如果把 AOP 代理對象的創(chuàng)建提前，那么二級緩存也一樣可以解決。但是，這就違背了 Spring 創(chuàng)建對象的原則，Spring 更喜歡把所有的普通 Bean 都初始化完成，在處理代理對象的初始化。

面試官：飛機，不錯嘛，這次了解了不少。那問個簡單的，你擼過循環(huán)依賴的解決方案?

謝飛機：哦哦，這沒有，沒實踐過!!!確實應(yīng)該搞一下，試試。

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

1. 問題描述

了解問題的本質(zhì)再分析問題，往往更利于對問題有更深入的了解和研究。所以我們在分析 Spring 關(guān)于循環(huán)依賴的源碼之前，先要了解下什么是循環(huán)依賴。

循環(huán)依賴分為三種，自身依賴于自身、互相循環(huán)依賴、多組循環(huán)依賴。

但無論循環(huán)依賴的數(shù)量有多少，循環(huán)依賴的本質(zhì)是一樣的。就是你的完整創(chuàng)建依賴于我，而我的完整創(chuàng)建也依賴于你，但我們互相沒法解耦，最終導(dǎo)致依賴創(chuàng)建失敗。

所以 Spring 提供了除了構(gòu)造函數(shù)注入和原型注入外的，setter循環(huán)依賴注入解決方案。那么我們也可以先來嘗試下這樣的依賴，如果是我們自己處理的話該怎么解決。

2. 問題體現(xiàn)

 
 
 
 
    
  
  
  
  
  1. public class ABTest { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static void main(String[] args) { 
    4.   
  
  
  
  4.         new ClazzA(); 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. class ClazzA { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.     private ClazzB b = new ClazzB(); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. class ClazzB { 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.     private ClazzA a = new ClazzA(); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. } 
    20.
  • 這段代碼就是循環(huán)依賴最初的模樣，你中有我，我中有你，運行就報錯 java.lang.StackOverflowError
  • 這樣的循環(huán)依賴代碼是沒法解決的，當你看到 Spring 中提供了 get/set 或者注解，這樣之所以能解決，首先是進行了一定的解耦。讓類的創(chuàng)建和屬性的填充分離，先創(chuàng)建出半成品Bean，再處理屬性的填充，完成成品Bean的提供。

3. 問題處理

在這部分的代碼中就一個核心目的，我們來自己解決一下循環(huán)依賴，方案如下：

 
 
 
 
    
  
  
  
  
  1. public class CircleTest { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     private final static Map singletonObjects = new ConcurrentHashMap<>(256); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public static void main(String[] args) throws Exception { 
    6.   
  
  
  
  6.         System.out.println(getBean(B.class).getA()); 
    7.   
  
  
  
  7.         System.out.println(getBean(A.class).getB()); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private static  T getBean(Class beanClass) throws Exception { 
    11.   
  
  
  
  11.         String beanName = beanClass.getSimpleName().toLowerCase(); 
    12.   
  
  
  
  12.         if (singletonObjects.containsKey(beanName)) { 
    13.   
  
  
  
  13.             return (T) singletonObjects.get(beanName); 
    14.   
  
  
  
  14.         } 
    15.   
  
  
  
  15.         // 實例化對象入緩存 
    16.   
  
  
  
  16.         Object obj = beanClass.newInstance(); 
    17.   
  
  
  
  17.         singletonObjects.put(beanName, obj); 
    18.   
  
  
  
  18.         // 屬性填充補全對象 
    19.   
  
  
  
  19.         Field[] fields = obj.getClass().getDeclaredFields(); 
    20.   
  
  
  
  20.         for (Field field : fields) { 
    21.   
  
  
  
  21.             field.setAccessible(true); 
    22.   
  
  
  
  22.             Class fieldClass = field.getType(); 
    23.   
  
  
  
  23.             String fieldBeanName = fieldClass.getSimpleName().toLowerCase(); 
    24.   
  
  
  
  24.             field.set(obj, singletonObjects.containsKey(fieldBeanName) ? singletonObjects.get(fieldBeanName) : getBean(fieldClass)); 
    25.   
  
  
  
  25.             field.setAccessible(false); 
    26.   
  
  
  
  26.         } 
    27.   
  
  
  
  27.         return (T) obj; 
    28.   
  
  
  
  28.     } 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30. } 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32. class A { 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.     private B b; 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36.     // ...get/set 
    37.   
  
  
  
  37. } 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39. class B { 
    40.   
  
  
  
  40.     private A a; 
    41.   
  
  
  
  41.  
    42.   
  
  
  
  42.   // ...get/set 
    43.   
  
  
  
  43. } 
    44.
  • 這段代碼提供了 A、B 兩個類，互相有依賴。但在兩個類中的依賴關(guān)系使用的是 setter 的方式進行填充。也就是只有這樣才能避免兩個類在創(chuàng)建之初不非得強依賴于另外一個對象。
  • getBean，是整個解決循環(huán)依賴的核心內(nèi)容，A 創(chuàng)建后填充屬性時依賴 B，那么就去創(chuàng)建 B，在創(chuàng)建 B 開始填充時發(fā)現(xiàn)依賴于 A，但此時 A 這個半成品對象已經(jīng)存放在緩存到singletonObjects 中了，所以 B 可以正常創(chuàng)建，在通過遞歸把 A 也創(chuàng)建完整了。

四、源碼分析

1. 說說細節(jié)

通過上面的例子我們大概了解到，A和B互相依賴時，A創(chuàng)建完后填充屬性B，繼續(xù)創(chuàng)建B，再填充屬性A時就可以從緩存中獲取了，如下：

那這個解決循環(huán)依賴的事放到 Spring 中是什么樣呢?展開細節(jié)!

雖然，解決循環(huán)依賴的核心原理一樣，但要放到支撐起整個 Spring 中 IOC、AOP 特性時，就會變得復(fù)雜一些，整個處理 Spring 循環(huán)依賴的過程如下;

  • 以上就是關(guān)于 Spring 中對于一個有循環(huán)依賴的對象獲取過程，也就是你想要的說說細節(jié)
  • 乍一看是挺多流程，但是這些也基本是你在調(diào)試代碼時候必須經(jīng)過的代碼片段，拿到這份執(zhí)行流程，再調(diào)試就非常方便了。

2. 處理過程

關(guān)于本章節(jié)涉及到的案例源碼分析，已更新到 github：https://github.com/fuzhengwei/interview - interview-31

以下是單元測試中對AB依賴的獲取Bean操作，重點在于進入 getBean 的源碼跟進;

 
 
 
 
    
  
  
  
  
  1. @Test 
    2.   
  
  
  
  2. public void test_alias() { 
    3.   
  
  
  
  3.     BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring-config.xml"); 
    4.   
  
  
  
  4.     Bean_A bean_a = beanFactory.getBean("bean_a", Bean_A.class); 
    5.   
  
  
  
  5.     logger.info("獲取 Bean 通過別名：{}", bean_a.getBean_b()); 
    6.   
  
  
  
  6. } 
    7.

org.springframework.beans.factory.support.AbstractBeanFactory.java

 
 
 
 
    
  
  
  
  
  1. @Override 
    2.   
  
  
  
  2. public  T getBean(String name, Class requiredType) throws BeansException { 
    3.   
  
  
  
  3.  return doGetBean(name, requiredType, null, false); 
    4.   
  
  
  
  4. } 
    5.
  • 從 getBean 進入后，獲取 bean 的操作會進入到 doGetBean。
  • 之所以這樣包裝一層，是因為 doGetBean 有很多不同入?yún)⒌闹剌d方法，方便外部操作。

doGetBean 方法

 
 
 
 
    
  
  
  
  
  1. protected  T doGetBean( 
    2.   
  
  
  
  2.   final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) 
    3.   
  
  
  
  3.   throws BeansException { 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5.   // 從緩存中獲取 bean 實例 
    6.   
  
  
  
  6.  Object sharedInstance = getSingleton(beanName); 
    7.   
  
  
  
  7.   
    8.   
  
  
  
  8.    // mbd.isSingleton() 用于判斷 bean 是否是單例模式 
    9.   
  
  
  
  9.    if (mbd.isSingleton()) { 
    10.   
  
  
  
  10.      // 獲取 bean 實例 
    11.   
  
  
  
  11.     sharedInstance = getSingleton(beanName, new ObjectFactory() {   
  
  
  
  12.      @Override 
    13.   
  
  
  
  13.      public Object getObject() throws BeansException { 
    14.   
  
  
  
  14.       try { 
    15.   
  
  
  
  15.         // 創(chuàng)建 bean 實例，createBean 返回的 bean 實例化好的 
    16.   
  
  
  
  16.        return createBean(beanName, mbd, args); 
    17.   
  
  
  
  17.       } 
    18.   
  
  
  
  18.       catch (BeansException ex) { 
    19.   
  
  
  
  19.        destroySingleton(beanName); 
    20.   
  
  
  
  20.        throw ex; 
    21.   
  
  
  
  21.       } 
    22.   
  
  
  
  22.      } 
    23.   
  
  
  
  23.     }); 
    24.   
  
  
  
  24.     // 后續(xù)的處理操作 
    25.   
  
  
  
  25.     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 
    26.   
  
  
  
  26.    } 
    27.   
  
  
  
  27.     
    28.   
  
  
  
  28.  // ... 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30.   // 返回 bean 實例 
    31.   
  
  
  
  31.  return (T) bean; 
    32.   
  
  
  
  32. } 
    33.  
 
 
 
      

    • 按照在源碼分析的流程圖中可以看到，這一部分是從 getSingleton 先判斷是否有實例對象，對于第一次進入是肯定沒有對象的，要繼續(xù)往下走。
    • 在判斷 mbd.isSingleton() 單例以后，開始使用基于 ObjectFactory 包裝的方式創(chuàng)建 createBean，進入后核心邏輯是開始執(zhí)行 doCreateBean 操作。
    

    doCreateBean 方法
     
 
 
 
      
  
  
  
  
    1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 
      2.   
  
  
  
    2.   throws BeanCreationException { 
      3.   
  
  
  
    3.   
      4.   
  
  
  
    4.    // 創(chuàng)建 bean 實例，并將 bean 實例包裝到 BeanWrapper 對象中返回 
      5.   
  
  
  
    5.   instanceWrapper = createBeanInstance(beanName, mbd, args); 
      6.   
  
  
  
    6.   
      7.   
  
  
  
    7.   // 添加 bean 工廠對象到 singletonFactories 緩存中 
      8.   
  
  
  
    8.   addSingletonFactory(beanName, new ObjectFactory() {   
  
  
  
    9.    @Override 
      10.   
  
  
  
    10.    public Object getObject() throws BeansException { 
      11.   
  
  
  
    11.      // 獲取原始對象的早期引用，在 getEarlyBeanReference 方法中，會執(zhí)行 AOP 相關(guān)邏輯。若 bean 未被 AOP 攔截，getEarlyBeanReference 原樣返回 bean。 
      12.   
  
  
  
    12.     return getEarlyBeanReference(beanName, mbd, bean); 
      13.   
  
  
  
    13.    } 
      14.   
  
  
  
    14.   }); 
      15.   
  
  
  
    15.    
      16.   
  
  
  
    16.  try { 
      17.   
  
  
  
    17.    // 填充屬性，解析依賴關(guān)系 
      18.   
  
  
  
    18.   populateBean(beanName, mbd, instanceWrapper); 
      19.   
  
  
  
    19.   if (exposedObject != null) { 
      20.   
  
  
  
    20.    exposedObject = initializeBean(beanName, exposedObject, mbd); 
      21.   
  
  
  
    21.   } 
      22.   
  
  
  
    22.  } 
      23.   
  
  
  
    23.   
      24.   
  
  
  
    24.  // 返回 bean 實例 
      25.   
  
  
  
    25.  return exposedObject; 
      26.   
  
  
  
    26. } 
      27.  
 
 
 
        

      • 在 doCreateBean 方法中包括的內(nèi)容較多，但核心主要是創(chuàng)建實例、加入緩存以及最終進行屬性填充，屬性填充就是把一個 bean 的各個屬性字段涉及到的類填充進去。
      • createBeanInstance，創(chuàng)建 bean 實例，并將 bean 實例包裝到 BeanWrapper 對象中返回
      • addSingletonFactory，添加 bean 工廠對象到 singletonFactories 緩存中
      • getEarlyBeanReference，獲取原始對象的早期引用，在 getEarlyBeanReference 方法中，會執(zhí)行 AOP 相關(guān)邏輯。若 bean 未被 AOP 攔截，getEarlyBeanReference 原樣返回 bean。
      • populateBean，填充屬性，解析依賴關(guān)系。也就是從這開始去找尋 A 實例中屬性 B，緊接著去創(chuàng)建 B 實例，最后在返回回來。
      

      getSingleton 三級緩存
       
 
 
 
        
  
  
  
  
      1. protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
        2.   
  
  
  
      2.   // 從 singletonObjects 獲取實例，singletonObjects 是成品 bean 
        3.   
  
  
  
      3.  Object singletonObject = this.singletonObjects.get(beanName); 
        4.   
  
  
  
      4.  // 判斷 beanName ，isSingletonCurrentlyInCreation 對應(yīng)的 bean 是否正在創(chuàng)建中 
        5.   
  
  
  
      5.  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
        6.   
  
  
  
      6.   synchronized (this.singletonObjects) { 
        7.   
  
  
  
      7.     // 從 earlySingletonObjects 中獲取提前曝光未成品的 bean 
        8.   
  
  
  
      8.    singletonObject = this.earlySingletonObjects.get(beanName); 
        9.   
  
  
  
      9.    if (singletonObject == null && allowEarlyReference) { 
        10.   
  
  
  
      10.      // 獲取相應(yīng)的 bean 工廠 
        11.   
  
  
  
      11.     ObjectFactory singletonFactory = this.singletonFactories.get(beanName); 
        12.   
  
  
  
      12.     if (singletonFactory != null) { 
        13.   
  
  
  
      13.       // 提前曝光 bean 實例，主要用于解決AOP循環(huán)依賴 
        14.   
  
  
  
      14.      singletonObject = singletonFactory.getObject(); 
        15.   
  
  
  
      15.       
        16.   
  
  
  
      16.      // 將 singletonObject 放入緩存中，并將 singletonFactory 從緩存中移除 
        17.   
  
  
  
      17.      this.earlySingletonObjects.put(beanName, singletonObject); 
        18.   
  
  
  
      18.      this.singletonFactories.remove(beanName); 
        19.   
  
  
  
      19.     } 
        20.   
  
  
  
      20.    } 
        21.   
  
  
  
      21.   } 
        22.   
  
  
  
      22.  } 
        23.   
  
  
  
      23.  return (singletonObject != NULL_OBJECT ? singletonObject : null); 
        24.   
  
  
  
      24. } 
        25.  
 
 
 
        

      • singletonObjects.get(beanName)，從 singletonObjects 獲取實例，singletonObjects 是成品 bean
      • isSingletonCurrentlyInCreation，判斷 beanName ，isSingletonCurrentlyInCreation 對應(yīng)的 bean 是否正在創(chuàng)建中
      • allowEarlyReference，從 earlySingletonObjects 中獲取提前曝光未成品的 bean
      • singletonFactory.getObject()，提前曝光 bean 實例，主要用于解決AOP循環(huán)依賴
      

      綜上，是一個處理循環(huán)依賴的代碼流程，這部分提取出來的內(nèi)容主要為核心內(nèi)容，并沒有長篇大論的全部拆取出來，大家在調(diào)試的時候會涉及的比較多，盡可能要自己根據(jù)流程圖操作調(diào)試幾遍。
      3. 依賴解析
      綜上從我們自己去嘗試解決循環(huán)依賴，學(xué)習(xí)了循環(huán)依賴的核心解決原理。又分析了 Spring 解決的循環(huán)依賴的處理過程以及核心源碼的分析。那么接下來我們在總結(jié)下三級緩存分別不同的處理過程，算是一個總結(jié)，也方便大家理解。
      1. 一級緩存能解決嗎?
      

        

      • 其實只有一級緩存并不是不能解決循環(huán)依賴，就像我們自己做的例子一樣。
      • 但是在 Spring 中如果像我們例子里那么處理，就會變得非常麻煩，而且也可能會出現(xiàn) NPE 問題。
      • 所以如圖按照 Spring 中代碼處理的流程，我們?nèi)シ治鲆患壘彺孢@樣存放成品 Bean 的流程中，是不能解決循環(huán)依賴的問題的。因為 A 的成品創(chuàng)建依賴于 B，B的成品創(chuàng)建又依賴于 A，當需要補全B的屬性時 A 還是沒有創(chuàng)建完，所以會出現(xiàn)死循環(huán)。
      

      2. 二級緩存能解決嗎?
      

        

      • 有了二級緩存其實這個事處理起來就容易了，一個緩存用于存放成品對象，另外一個緩存用于存放半成品對象。
      • A 在創(chuàng)建半成品對象后存放到緩存中，接下來補充 A 對象中依賴 B 的屬性。
      • B 繼續(xù)創(chuàng)建，創(chuàng)建的半成品同樣放到緩存中，在補充對象的 A 屬性時，可以從半成品緩存中獲取，現(xiàn)在 B 就是一個完整對象了，而接下來像是遞歸操作一樣 A 也是一個完整對象了。
      

      3. 三級緩存解決什么?
      有了二級緩存都能解決 Spring 依賴了，怎么要有三級緩存呢。其實我們在前面分析源碼時也提到過，三級緩存主要是解決 Spring AOP 的特性。AOP 本身就是對方法的增強，是 ObjectFactory 類型的 lambda 表達式，而 Spring 的原則又不希望將此類類型的 Bean 前置創(chuàng)建，所以要存放到三級緩存中處理。
      其實整體處理過程類似，唯獨是 B 在填充屬性 A 時，先查詢成品緩存、再查半成品緩存，最后在看看有沒有單例工程類在三級緩存中。最終獲取到以后調(diào)用 getObject 方法返回代理引用或者原始引用。
      至此也就解決了 Spring AOP 所帶來的三級緩存問題。本章節(jié)涉及到的 AOP 依賴有源碼例子，可以進行調(diào)試 https://github.com/fuzhengwei/interview
      五、總結(jié)
      回顧本文基本以實際操作的例子開始，引導(dǎo)大家對循環(huán)依賴有一個整體的認識，也對它的解決方案可以上手的例子，這樣對后續(xù)的關(guān)于 Spring 對循環(huán)依賴的解決也就不會那么陌生了。
      通篇全文下來大家也可以看到，三級緩存并不是非必須不可，只不過在滿足 Spring 自身創(chuàng)建的原則下，是必須的。如果你可以下載 Spring 源碼對這部分代碼進行改動下，提前創(chuàng)建 AOP 對象保存到緩存中，那么二級緩存一樣可以解決循環(huán)依賴問題。
      關(guān)于循環(huán)依賴可能并不是一個好的編碼方式，如果在自己的程序中還是要盡可能使用更合理的設(shè)計模式規(guī)避循環(huán)依賴，可能這些方式會增加代碼量，但在維護上會更加方便。當然這不是強制，可以根據(jù)你的需要而來。
                                                      
      
                                                當前名稱：SpringBeanIOC、AOP循環(huán)依賴解讀                                                
      
                                                鏈接URL：http://www.5511xx.com/article/cdhchpd.html