我們知道，Spring 中 AOP 是一大核心技術，也是面試中經常會被問到的問題，最近我在網上也看到很多面試題，其中和 Spring AOP 相關的就有不少，這篇文章主要來總結下相關的技術點，希望對大家有用。

1. 幾個常見的問題

針對這一塊的東西，一般下面幾個問題面試官問的比較多：
Spring AOP用的是哪種設計模式？
談談你對代理模式的理解？
靜態(tài)代理和動態(tài)代理有什么區(qū)別？
如何實現動態(tài)代理？
Spring AOP中用的是哪種代理技術？

如果這些問題都能回答的很流暢的話，說明對代理這一塊的基本知識有一定的了解了。因為我們在實際開發(fā)中，寫業(yè)務代碼會更多，所以這一塊的東西，大部分人可能知道個一二，但是如果讓他們很有條理的表達出來，可能就不那么容易了。

1. 什么是 Spring AOP？

一般面試官問到這個問題，面試者基本上都會回答：AOP 就是面向切面編程。其實這真的是句廢話，這么回答真的沒有任何意義。

或許你可以給面試官舉個例子：歌星都有好多助理，歌星最重要的一件事就是唱歌，其他事他不用關注，比如唱歌前可能需要和其他人談合作，還要布置場地，唱歌后還要收錢等等，這些統(tǒng)統(tǒng)交給他對應的助理去做。也許哪一天，這個歌星做慈善，免費唱歌了，不收錢了，那么就可以把收錢這個助力給辭退了。這就是 AOP，每個人各司其職，靈活組合，達到一種可配置的、可插拔的程序結構。AOP 的實現原理就是代理模式。

在程序中也是如此，通過代理，可以詳細控制訪問某個或者某類對象的方法，在調用這個方法前做前置處理，調用這個方法后做后置處理。

2. 什么是代理模式？

代理模式的核心作用就是通過代理，控制對對象的訪問。它的設計思路是：定義一個抽象角色，讓代理角色和真實角色分別去實現它。

真實角色：實現抽象角色，定義真實角色所要實現的業(yè)務邏輯，供代理角色調用。它只關注真正的業(yè)務邏輯，比如歌星唱歌。

代理角色：實現抽象角色，是真實角色的代理，通過真實角色的業(yè)務邏輯方法來實現抽象方法，并在前后可以附加自己的操作，比如談合同，布置場地，收錢等等。

這就是代理模式的設計思路。代理模式分為靜態(tài)代理和動態(tài)代理。靜態(tài)代理是我們自己創(chuàng)建一個代理類，而動態(tài)代理是程序自動幫我們生成一個代理，我們就不用管了。下面我詳細介紹一下這兩種代理模式。

3. 靜態(tài)代理模式

就舉明星唱歌這個例子，根據上面提供的設計思路，首先我們需要創(chuàng)建明星這個抽象角色，

/**

• 明星接口類

• @author shengwu ni

• @date 2018-12-07

*/

public interface Star {

/**

* 唱歌方法

*/

void sing();

}

靜態(tài)代理需要創(chuàng)建真實角色和代理角色，分別實現唱歌這個接口，真實角色很簡單，直接實現即可，因為真實角色的主要任務就是唱歌。

/**

• 真實明星類

• @author shengwu ni

• @date 2018-12-08
  */
  public class RealStar implements Star {

  @Override
  public void sing() {
  System.out.println("明星本人開始唱歌……");
  }
  }

代理類就需要做點工作了，我們思考一下，代理只是在明星唱歌前后做一些準備和收尾的事，唱歌這件事還得明星親自上陣，代理做不了。所以代理類里面是肯定要將真實的對象傳進來。有了思路，我們將代理類寫出來。

/**

• 明星的靜態(tài)代理類

• @author shengwu ni

• @date 2018-12-08
  */
  public class ProxyStar implements Star {

  /**

  • 接收真實的明星對象
    */
    private Star star;

  /**

  • 通過構造方法傳進來真實的明星對象
  • @param star star
    */
    public ProxyStar(Star star) {
    this.star = star;
    }

  @Override
  public void sing() {
  System.out.println("代理先進行談判……");
  // 唱歌只能明星自己唱
  this.star.sing();
  System.out.println("演出完代理去收錢……");
  }

}

這樣的話，邏輯就非常清晰了。在代理類中，可以看到，維護了一個Star對象，通過構造方法傳進來一個真實的Star對象給其賦值，然后在唱歌這個方法里，使用真實對象來唱歌。所以說面談、收錢都是由代理對象來實現的，唱歌是代理對象讓真實對象來做。下面寫個客戶端測試下。

/**

• 測試客戶端

• @author shengwu ni

• @date 2018-12-08
  */
  public class Client {

  /**

  • 測試靜態(tài)代理結果

  • @param args args
    */
    public static void main(String[] args) {
    Star realStar = new RealStar();
    Star proxy = new ProxyStar(realStar);

    proxy.sing();
    }
    }

讀者可以自己運行下結果，靜態(tài)代理比較簡單。動態(tài)代理比靜態(tài)代理使用的更廣泛，動態(tài)代理在本質上，代理類不用我們來管，我們完全交給工具去生成代理類即可。動態(tài)代理一般有兩種方式：JDK 動態(tài)代理和 CGLIB 動態(tài)代理。

4. JDK 動態(tài)代理

既然動態(tài)代理不需要我們去創(chuàng)建代理類，那我們只需要編寫一個動態(tài)處理器就可以了。真正的代理對象由 JDK 在運行時為我們動態(tài)的來創(chuàng)建。

/**

• 動態(tài)代理處理類

• @author shengwu ni

• @date 2018-12-08
  */
  public class JdkProxyHandler {

  /**

  • 用來接收真實明星對象
    */
    private Object realStar;

  /**

  • 通過構造方法傳進來真實的明星對象
  • @param star star
    */
    public JdkProxyHandler(Star star) {
    super();
    this.realStar = star;
    }

  /**

  • 給真實對象生成一個代理對象實例

  • @return Object
    */
    public Object getProxyInstance() {
    return Proxy.newProxyInstance(realStar.getClass().getClassLoader(),
    realStar.getClass().getInterfaces(), (proxy, method, args) -> {

             System.out.println("代理先進行談判……");
             // 唱歌需要明星自己來唱
             Object object = method.invoke(realStar, args);
             System.out.println("演出完代理去收錢……");
    
             return object;
         });
    

  }
  }

這里說一下 Proxy.newProxyInstance() 方法，該方法接收三個參數：第一個參數指定當前目標對象使用的類加載器,獲取加載器的方法是固定的；第二個參數指定目標對象實現的接口的類型；第三個參數指定動態(tài)處理器，執(zhí)行目標對象的方法時,會觸發(fā)事件處理器的方法。網上針對第三個參數的寫法都是 new 一個匿名類來處理，我這直接用的 Java8 里面的 lamda 表達式來寫的，都一樣。底層原理使用的是反射機制。接下來寫一個客戶端程序來測試下。

/**

• 測試客戶端

• @author shengwu ni

• @date 2018-12-08
  */
  public class Client {

  /**

  • 測試JDK動態(tài)代理結果

  • @param args args
    */
    public static void main(String[] args) {
    Star realStar = new RealStar();
    // 創(chuàng)建一個代理對象實例
    Star proxy = (Star) new JdkProxyHandler(realStar).getProxyInstance();

    proxy.sing();
    }
    }

可以看出，創(chuàng)建一個真實的對象，送給 JdkProxyHandler 就可以創(chuàng)建一個代理對象了。

我們對 JDK 動態(tài)代理做一個簡單的總結：相對于靜態(tài)代理，JDK 動態(tài)代理大大減少了我們的開發(fā)任務，同時減少了對業(yè)務接口的依賴，降低了耦合度。JDK 動態(tài)代理是利用反射機制生成一個實現代理接口的匿名類，在調用具體方法前調用InvokeHandler 來處理。但是 JDK 動態(tài)代理有個缺憾，或者說特點：JDK 實現動態(tài)代理需要實現類通過接口定義業(yè)務方法。也就是說它始終無法擺脫僅支持 interface 代理的桎梏，因為它的設計就注定了這個遺憾。

5. CGLIB 動態(tài)代理

由上面的分析可知，JDK 實現動態(tài)代理需要實現類通過接口定義業(yè)務方法，那對于沒有接口的類，如何實現動態(tài)代理呢，這就需要 CGLIB 了。

CGLIB 采用了非常底層的字節(jié)碼技術，其原理是通過字節(jié)碼技術為一個類創(chuàng)建子類，并在子類中采用方法攔截的技術攔截所有父類方法的調用，順勢織入橫切邏輯。但因為采用的是繼承，所以不能對final修飾的類進行代理。我們來寫一個 CBLIB 代理類。

/**

• cglib代理處理類

• @author shengwu ni

• @date 2018-12-08
  */
  public class CglibProxyHandler implements MethodInterceptor {

  /**

  • 維護目標對象
    */
    private Object target;

  public Object getProxyInstance(final Object target) {
  this.target = target;
  // Enhancer類是CGLIB中的一個字節(jié)碼增強器，它可以方便的對你想要處理的類進行擴展
  Enhancer enhancer = new Enhancer();
  // 將被代理的對象設置成父類
  enhancer.setSuperclass(this.target.getClass());
  // 回調方法，設置攔截器
  enhancer.setCallback(this);
  // 動態(tài)創(chuàng)建一個代理類
  return enhancer.create();
  }

  @Override
  public Object intercept(Object object, Method method, Object[] args,
  MethodProxy methodProxy) throws Throwable {

   System.out.println("代理先進行談判……");
   // 唱歌需要明星自己來唱
   Object result = methodProxy.invokeSuper(object, args);
   System.out.println("演出完代理去收錢……");
   return result;
  

  }
  }

使用 CGLIB 需要實現 MethodInterceptor 接口，并重寫intercept 方法，在該方法中對原始要執(zhí)行的方法前后做增強處理。該類的代理對象可以使用代碼中的字節(jié)碼增強器來獲取。接下來寫個客戶端測試程序。

/**

• 測試客戶端

• @author shengwu ni

• @date 2018-12-08
  */
  public class Client {

  /**

  • 測試Cglib動態(tài)代理結果

  • @param args args
    */
    public static void main(String[] args) {
    Star realStar = new RealStar();
    Star proxy = (Star) new CglibProxyHandler().getProxyInstance(realStar);

    proxy.sing();
    }
    }

這個客戶端測試程序和 JDK 動態(tài)代理的邏輯一模一樣，所以也可以看出，代理模式中的動態(tài)代理，其實套路都是相同的，只是使用了不同的技術而已。

我們也對 CGLIB 動態(tài)代理做一下總結：CGLIB 創(chuàng)建的動態(tài)代理對象比 JDK 創(chuàng)建的動態(tài)代理對象的性能更高，但是 CGLIB 創(chuàng)建代理對象時所花費的時間卻比 JDK 多得多。所以對于單例的對象，因為無需頻繁創(chuàng)建對象，用 CGLIB 合適，反之使用JDK方式要更為合適一些。同時由于 CGLIB 由于是采用動態(tài)創(chuàng)建子類的方法，對于final修飾的方法無法進行代理。

當然了，不管是哪種動態(tài)代理技術，在上面的代碼里，要代理的類中可能不止一種方法，有時候我們需要對特定的方法進行增強處理，所以可以對傳入的 method 參數進行方法名的判斷，再做相應的處理。

6. Spring AOP 采用哪種代理？

JDK 動態(tài)代理和 CGLIB 動態(tài)代理均是實現 Spring AOP 的基礎。對于這一塊內容，面試官問的比較多，他們往往更想聽聽面試者是怎么回答的，有沒有看過這一塊的源碼等等。

針對于這一塊內容，我們看一下 Spring 5 中對應的源碼是怎么說的。

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
// 判斷目標類是否是接口或者目標類是否Proxy類型，若是則使用JDK動態(tài)代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 配置了使用CGLIB進行動態(tài)代理或者目標類沒有接口，那么使用CGLIB的方式創(chuàng)建代理對象
return new ObjenesisCglibAopProxy(config);
}
else {
// 上面的三個方法沒有一個為true，那使用JDK的提供的代理方式生成代理對象
return new JdkDynamicAopProxy(config);
}
}
//其他方法略……
}

從上述源碼片段可以看出，是否使用 CGLIB 是在代碼中進行判斷的，判斷條件是 config.isOptimize()、config.isProxyTargetClass() 和 hasNoUserSuppliedProxyInterfaces(config)。

其中，config.isOptimize() 與 config.isProxyTargetClass()默認返回都是 false，這種情況下判斷結果就由

hasNoUserSuppliedProxyInterfaces(config)的結果決定了。
簡單來說，
hasNoUserSuppliedProxyInterfaces(config) 就是在判斷代理的對象是否有實現接口，有實現接口的話直接走 JDK 分支，即使用 JDK 的動態(tài)代理。

所以基本上可以總結出 Spring AOP 中的代理使用邏輯了：如果目標對象實現了接口，默認情況下會采用 JDK 的動態(tài)代理實現 AOP；如果目標對象沒有實現了接口，則采用 CGLIB 庫，Spring 會自動在 JDK 動態(tài)代理和 CGLIB 動態(tài)代理之間轉換。

當然，源碼我也沒讀那么深，暫且就只能寫到這，后面深入了，有新的見解再給大家分享。還記得文章開頭的幾個問題嗎？相信你讀到這里，心中應該已經有了答案了。

如果覺得對自己有幫助，可以轉發(fā)給更多的伙伴們。