如何實現一個簡易版的 Spring - 如何實現 AOP（中）

本文轉載自查看原文 2021-05-30 14:36 246 Java

前言

在上篇如何實現 AOP（上）介紹了 AOP 技術出現的原因和一些重要的概念，在我們自己實現之前有必要先了解一下 AOP 底層到底是如何運作的，所以這篇再來看看 AOP 實現所依賴的一些核心基礎技術。AOP 是使用動態代理和字節碼生成技術來實現的，在運行期（注意：不是編譯期！）為目標對象生成代理對象，然后將橫切邏輯織入到生成的代理對象中，最后系統使用的是帶有橫切邏輯的代理對象，而不是被代理對象，由代理對象轉發到被代理對象。

代理模式

動態代理的根源是設計模式中的代理模式，代理模式在 GoF 中的描述如下：

Provide a surrogate or placeholder for another object to control access to it.

從其定義可以看出，代理模式主要是為了控制對象的訪問，通常也會擁有被代理者的所有功能。通過代理模式我們可以在不改變被代理類的情況下，通過引入代理類來給被代理類添加一些功能，此時腦海里飄過計算機科學界中一句著名的話(P.S. 基礎知識很重要啊，可以參見這篇)：

計算機科學的任何一個問題，都可以通過增加一個中間層來解決。

代理模式其實在現實生活中也經常會接觸到，比如在一線城市租房時大部分都是找的租房中介去看的房子、談價格以及簽合同，是因為房子的房東已經把房子全權托管給了中介處理了，這里的租房中介其實就是充當了代理模式中的代理對象的解決，而真正的被代理對象(目標對象)其實是房子的房東，而和我們打交道都是租房中介(代理對象)。代理模式類圖結構如下圖所示：

圖中各個部分的含義如下：

ISubject 是被代理對象所能提供能力的抽象。
SubjectImpl 是被代理的具體實現類。
SubjectProxy 是代理的實現類，通常該類持有 ISubject 接口的實例。
Client 是訪問者的抽象角色，要訪問 ISubject 類型的資源。

可以看到 SubjectImpl 和 SubjectProxy 都實現了相同的接口 ISubject，在代理對象 SubjectProxy 內持有 ISubject 的引用，當 Client 訪問 doOperation() 時，代理對象將請求轉發給被代理對象，單單從這個過程來看，代理對象如果只是為了轉發請求，是不是有點多此一舉了？再結合代理模式的定義思考一下，在轉發之前（后者之后）不就可以添加一些訪問控制了嗎。

在代理對象(SubjectProxy)將請求轉發給被代理對象(SubejctImpl)之前或者之后都是根據需要添加一些處理邏輯，而不需要修改被代理對象的具體實現邏輯，假設 SubjectImpl 是我們系統中 Joinpoint 所在的對象，此時 SubjectImpl 就是我們的目標對象了，只需要為這個目標對象創建一個代理對象，然后將橫切邏輯添加到代理對象中，對外暴露出創建出來的代理對象就可以將將橫切邏輯和原來的邏輯融合在一起了。

動態代理

到目前為止，一切都是那么美好，當只為同一個目標對象類型添加橫切邏輯時，只需要創建一個代理對象即可，但是在 Joinpoint 相同而目標對象類型不同時，需要為每個不同的目標對象類型都單獨創建一個代理對象，而這些代理對象的橫切邏輯其實都是一樣的，根據 DRY原則，需要尋找另一種技術來解決這個問題。
在 JDK 1.3 引入的動態代理機制可以為指定的接口在運行期動態的去生成代理對象，使用這個動態代理機制可以解決上述問題，這樣我們就可以不事先為每個原始類創建代理類，而是在運行時動態生成代理類。在 Java 中，使用動態代理是比較簡單的，它本身就已經使用反射實現了動態代理的語法，主要是由一個類 Proxy 和一個接口 InvocationHandler 組成，使用動態代理機制實現前文示例如下：

/**
 * @author mghio
 * @since 2021-05-29
 */
public interface Subject {
  void doOperation();
}

public class SubjectImpl implements Subject {
  @Override
  public void doOperation() {
    System.out.println("SubjectImpl doOperation...");
  }
}

public class JDKInvocationHandler implements InvocationHandler {
  private final Subject target;
  public JDKInvocationHandler(Subject target) {
    this.target = target;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // add pre process logic if necessary
    
    System.out.println("Proxy before JDKInvocationHandler doOperation...");
    Object result = method.invoke(target, args);
    System.out.println("Proxy after JDKInvocationHandler doOperation...");

    // add post process logic if necessary
    return result;
  }
}

public class Client {
  public static void main(String[] args) {
    // 將生成的代理類保存在根目錄下（com/sun/proxy/XXX.class）
    System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    Subject target = new SubjectImpl();
    Subject proxy = (Subject) Proxy.newProxyInstance(SubjectImpl.class.getClassLoader(),
        new Class[]{Subject.class}, new JDKInvocationHandler(target));
    proxy.doOperation();
  }
}

由以上代碼可知，使用 JDK 的動態代理只要 3 步：

定義公共接口 Subject，創建被代理對象 SubjectImpl
創建被代理對象的處理對象 JDKInvocationHandler，持有目標對象 Subject 的引用
使用 JDK 的 Proxy 類的靜態方法 newProxyInstance 創建代理對象

通過設置 sun.misc.ProxyGenerator.saveGeneratedFiles 屬性，可以將動態生成的代理類保存在項目根目錄下，運行上面的示例代碼生成的代理類如下：

public final class $Proxy0 extends Proxy implements Subject {
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;

  static {
    try {
      m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
      m2 = Class.forName("java.lang.Object").getMethod("toString");
      m3 = Class.forName("cn.mghio.designpattern.proxy.dynamicproxy.Subject").getMethod("doOperation");
      m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
      throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
      throw new NoClassDefFoundError(var3.getMessage());
    }
  }

  public $Proxy0(InvocationHandler var1) throws  {
    super(var1);
  }

  public final void doOperation() throws  {
    try {
      super.h.invoke(this, m3, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  // omit toString、equals、hashCode method...

}

從動態生成的代理類的代碼可以看出，JDK 動態代理生成的代理類是繼承 JDK 中提供的 Proxy 和實現被代理類所實現的接口。進一步可以從這個實現方式得出兩點：1. 使用 JDK 動態代理時為什么只能使用接口引用指向代理，而不能使用被代理的具體類引用指向代理；2. 被代理類必須實現接口，因為 JDK 動態代理生成的代理類必須繼承自 Proxy，而 Java 不支持多重繼承，所以只能通過實現接口的方式。

在默認情況下，Spring AOP 發現了目標對象實現了接口，會使用 JDK 動態代理機制為其動態生成代理對象，雖然提倡面向接口編程，但是也有目標對象沒有實現接口的場景，當被代理的目標對象沒有實現接口時就無法使用 JDK 動態代理了，那么這種情況下就需要使用第三方工具來幫忙了。

字節碼生成技術

當目標對象沒有實現接口時，可以通過動態字節碼生成來繼承目標對象來動態生成相應的子類，在生成的子類中重寫父類目標對象的行為，然后將橫切邏輯放在子類，在系統中使用目標對象的子類，最終的效果是代理模式是一樣的，CGLIB 動態字節碼生成類庫（它本身其實也是一個抽象層，更底層是 ASM）可以動態生成和修改一個類的字節碼。當以上示例代碼目標對象未實現接口時修改為 CGLIB 動態生成字節碼方式實現如下：

/**
 * @author mghio
 * @since 2021-05-29
 */
public class RealSubject {
  public void doOperation() {
    System.out.println("RealSubject doOperation...");
  }
}

public class CglibMethodInterceptor implements MethodInterceptor {
  @Override
  public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy)
      throws Throwable {
    // add pre process logic if necessary

    System.out.println("Cglib before RealSubject doOperation...");
    Object result = methodProxy.invokeSuper(o, args);
    System.out.println("Cglib after RealSubject doOperation...");

    // add post process logic if necessary
    return result;
  }
}

public class Client {
  public static void main(String[] args) {
    // 將生成的動態代理類保存到文件中
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
        "/Users/mghio/IdeaProjects/designpattern/cglib/proxy/");
    // 1. 創建 Enhancer 對象
    Enhancer enhancer = new Enhancer();
    // 2. 設置被代理類
    enhancer.setSuperclass(RealSubject.class);
    // 3. 設置回調對象(實現 MethodInterceptor 接口)
    enhancer.setCallback(new CglibMethodInterceptor());
    // 4. 創建代理對象
    RealSubject proxy = (RealSubject) enhancer.create();
    proxy.doOperation();
  }
}

使用 CGLIB 生成代理對象需要 4 步：

創建 Enhancer 對象，動態生成字節碼的絕大部分邏輯都是在這個類中完成的。
設置被代理類(目標對象)，生成的代理類會繼承自這個接口，也就意味着這個類不能是 final 類型的。
設置回調對象(實現 MethodInterceptor 接口)，在這里根據需要添加橫切邏輯。
調用 Enhaner 的 create() 方法創建代理對象。

在設置 DebuggingClassWriter.DEBUG_LOCATION_PROPERTY 屬性后，反編譯已保存的動態生成代理類如下：

從反編譯后的代碼可以看出 CGLIB 生成的代理類是通過繼承被代理類 RealSubject 實現 Factory 接口實現的，要能被繼承也就要求被代理類不能是 final 類型的。看到這里你可能會問：既然 JDK 動態代理要求被代理類實現接口，而 CGLIB 動態字節碼生成要求不能是 final 類，那對於那些沒有實現接口同時還是 final 類，要怎么動態代理呢？好問題，這個就留給你自己去思考了。

總結

本文簡要介紹了 Spring AOP 實現所依賴的核心基礎技術，從動態代理的根源代理模式到動態代理和動態字節碼生成技術，為下篇動手實現簡易版的 AOP 打下基礎，在了解了所依賴的基礎技術后，在具體實現時就會更加絲滑，動態代理和動態字節碼生成對比如下：

對比項	JDK 動態代理	CGLIB
生成代理類的方式	繼承 JDK 中 Proxy，實現被代理類的所有接口	繼承被代理類，實現 CGLIB 的 Factory 接口
被代理對象的要求	必須實現接口，可以是 final 類	非 final 類，方法也要是非 final 類型的
集成方式	JDK 內置	第三方動態字節碼生成類庫

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 如何實現一個簡易版的 Spring - 如何實現 AOP（上）如何實現一個簡易版的 Spring - 如何實現 AOP（下）如何實現一個簡易版的 Spring - 如何實現 AOP（終結篇）如何實現一個簡易版的 Spring - 如何實現 @Component 注解如何實現一個簡易版的 Spring - 如何實現 @Autowired 注解自己實現簡易版AOP，含AOP實現的步驟分解基於 Mysql 實現一個簡易版搜索引擎 Vue源碼分析之實現一個簡易版的Vue 3行代碼實現一個簡易版promise 手動實現一個簡易版SpringMvc