十分鐘理解Java之動態代理

本篇文章會從代理的概念出發，介紹Java中動態代理技術的使用，並進一步探索它的實現原理。由於個人水平有限，敘述中難免出現不清晰或是不準確的地方，希望大家可以指正，謝謝大家：）

概述

什麼是代理

我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理爲其銷售商品。關於微商代理，首先我們從他們那裏買東西時通常不知道背後的廠家究竟是誰，也就是說，“委託者”對我們來說是不可見的；其次，微商代理主要以朋友圈的人爲目標客戶，這就相當於爲廠家做了一次對客戶羣體的“過濾”。我們把微商代理和廠家進一步抽象，前者可抽象爲代理類，後者可抽象爲委託類（被代理類）。通過使用代理，通常有兩個優點，並且能夠分別與我們提到的微商代理的兩個特點對應起來：

• 優點一：可以隱藏委託類的實現；
• 優點二：可以實現客戶與委託類間的解耦，在不修改委託類代碼的情況下能夠做一些額外的處理。

靜態代理

若代理類在程序運行前就已經存在，那麼這種代理方式被成爲靜態代理，這種情況下的代理類通常都是我們在Java代碼中定義的。 通常情況下，靜態代理中的代理類和委託類會實現同一接口或是派生自相同的父類。下面我們用Vendor類代表生產廠家，BusinessAgent類代表微商代理，來介紹下靜態代理的簡單實現，委託類和代理類都實現了Sell接口，Sell接口的定義如下：

 

public interface Sell { void sell(); void ad();}

Vendor類的定義如下：

 

public class Vendor implements Sell { 
  public void sell() { 
    System.out.println("In sell method"); 
  } 
  public void ad() { 
    System.out.println("ad method") 
  }
}

代理類BusinessAgent的定義如下：

 

public class BusinessAgent implements Sell {
  private Vendor mVendor; 
  public BusinessAgent(Vendor vendor) {
    mVendor = vendor;
  }
  public void sell() { 
   mVendor.sell(); 
 }
 public void ad() { 
   mVendor.ad(); 
 }
}

從BusinessAgent類的定義我們可以瞭解到，靜態代理可以通過聚合來實現，讓代理類持有一個委託類的引用即可。
下面我們考慮一下這個需求：給Vendor類增加一個過濾功能，只賣貨給大學生。通過靜態代理，我們無需修改Vendor類的代碼就可以實現，只需在BusinessAgent類中的sell方法中添加一個判斷即可如下所示：

 

public class BusinessAgent implements Sell { 
  ... 
  public void sell() { 
    if (isCollegeStudent()) { 
      vendor.sell(); 
    } 
  } 
  ...
}

這對應着我們上面提到的使用代理的第二個優點：可以實現客戶與委託類間的解耦，在不修改委託類代碼的情況下能夠做一些額外的處理。靜態代理的侷限在於運行前必須編寫好代理類，下面我們重點來介紹下運行時生成代理類的動態代理方式。

動態代理

什麼是動態代理

代理類在程序運行時創建的代理方式被成爲動態代理。也就是說，這種情況下，代理類並不是在Java代碼中定義的，而是在運行時根據我們在Java代碼中的“指示”動態生成的。相比於靜態代理，動態代理的優勢在於可以很方便的對代理類的函數進行統一的處理，而不用修改每個代理類的函數。這麼說比較抽象，下面我們結合一個實例來介紹一下動態代理的這個優勢是怎麼體現的。
現在，假設我們要實現這樣一個需求：在執行委託類中的方法之前輸出“before”，在執行完畢後輸出“after”。我們還是以上面例子中的Vendor類作爲委託類，BusinessAgent類作爲代理類來進行介紹。首先我們來使用靜態代理來實現這一需求，相關代碼如下：

 

public class BusinessAgent implements Sell { 
  private Vendor mVendor; 
  public BusinessAgent(Vendor vendor) { 
    this.mVendor = vendor; 
  } 
  public void sell() { 
    System.out.println("before"); 
    mVendor.sell(); 
    System.out.println("after"); 
  } 
  public void ad() { 
    System.out.println("before"); 
    mVendor.ad(); 
    System.out.println("after"); 
  }
}

從以上代碼中我們可以瞭解到，通過靜態代理實現我們的需求需要我們在每個方法中都添加相應的邏輯，這裏只存在兩個方法所以工作量還不算大，假如Sell接口中包含上百個方法呢？這時候使用靜態代理就會編寫許多冗餘代碼。通過使用動態代理，我們可以做一個“統一指示”，從而對所有代理類的方法進行統一處理，而不用逐一修改每個方法。下面我們來具體介紹下如何使用動態代理方式實現我們的需求。

使用動態代理

InvocationHandler接口

在使用動態代理時，我們需要定義一個位於代理類與委託類之間的中介類，這個中介類被要求實現InvocationHandler接口，這個接口的定義如下：

 

public interface InvocationHandler { 
  Object invoke(Object proxy, Method method, Object[] args);
}

從InvocationHandler這個名稱我們就可以知道，實現了這個接口的中介類用做“調用處理器”。當我們調用代理類對象的方法時，這個“調用”會轉送到invoke方法中，代理類對象作爲proxy參數傳入，參數method標識了我們具體調用的是代理類的哪個方法，args爲這個方法的參數。這樣一來，我們對代理類中的所有方法的調用都會變爲對invoke的調用，這樣我們可以在invoke方法中添加統一的處理邏輯（也可以根據method參數對不同的代理類方法做不同的處理）。因此我們只需在中介類的invoke方法實現中輸出“before”，然後調用委託類的invoke方法，再輸出“after”。下面我們來一步一步具體實現它。

委託類的定義

動態代理方式下，要求委託類必須實現某個接口，這裏我們實現的是Sell接口。委託類Vendor類的定義如下：

 

public class Vendor implements Sell { 
  public void sell() { 
    System.out.println("In sell method"); 
  } 
  public void ad() { 
    System.out.println("ad method") 
  }
}

中介類

上面我們提到過，中介類必須實現InvocationHandler接口，作爲調用處理器”攔截“對代理類方法的調用。中介類的定義如下：

 

public class DynamicProxy implements InvocationHandler {
  private Object obj; //obj爲委託類對象
  public DynamicProxy(Object obj) {
    this.obj = obj;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("before");
    Object result = method.invoke(obj, args);
    System.out.println("after");
    return result;
  }
}

從以上代碼中我們可以看到，中介類持有一個委託類對象引用，在invoke方法中調用了委託類對象的相應方法，看到這裏是不是覺得似曾相識？通過聚合方式持有委託類對象引用，把外部對invoke的調用最終都轉爲對委託類對象的調用。這不就是我們上面介紹的靜態代理的一種實現方式嗎？實際上，中介類與委託類構成了靜態代理關係，在這個關係中，中介類是代理類，委託類就是委託類；代理類與中介類也構成一個靜態代理關係，在這個關係中，中介類是委託類，代理類是代理類。也就是說，動態代理關係由兩組靜態代理關係組成，這就是動態代理的原理。下面我們來介紹一下如何”指示“以動態生成代理類。

動態生成代理類

動態生成代理類的相關代碼如下：

 

public class Main { public static void main(String[] args) { 
  DynamicProxy inter = new DynamicProxy(new Vendor()); 
  //加上這句將會產生一個$Proxy0.class文件，這個文件即爲動態生成的代理類文件
  System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
  //獲取代理類實例sell 
  Sell sell = (Sell)(Proxy.newProxyInstance(Sell.class.getClassLoader(), new Class[] {Sell.class}, inter)); 
  sell.sell(); 
  sell.ad(); 
  }
}

在以上代碼中，我們調用Proxy類的newProxyInstance方法來獲取一個代理類實例。這個代理類實現了我們指定的接口並且會把方法調用分發到指定的調用處理器。這個方法的聲明如下：

 

public static Object newProxyInstance(ClassLoader loader, 
    Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

方法的三個參數含義分別如下：

• loader：定義了代理類的ClassLoder；

• interfaces：代理類實現的接口列表

• h：調用處理器，也就是我們上面定義的實現了InvocationHandler接口的類實例

  我們運行一下，看看我們的動態代理是否能正常工作。我這裏運行後的輸出爲：

   

  說明我們的動態代理確實奏效了。

  上面我們已經簡單提到過動態代理的原理，這裏再簡單的總結下：首先通過newProxyInstance方法獲取代理類實例，而後我們便可以通過這個代理類實例調用代理類的方法，對代理類的方法的調用實際上都會調用中介類（調用處理器）的invoke方法，在invoke方法中我們調用委託類的相應方法，並且可以添加自己的處理邏輯。下面我們來看一下生成的代理類的代碼究竟是怎樣的。

動態代理類的源碼分析

通過運行Main，我們會得到一個名爲“$Proxy”的class文件，這個文件即爲動態生成的代理類，我們通過反編譯來查看下這個代理類的源代碼：

 

package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Sell { 
  //這5個Method對象分別代表equals()、toString()、ad()、sell()、hashCode()方法 
  private static Method m1; 
  private static Method m2; 
  private static Method m4; 
  private static Method m3; 
  private static Method m0; 
  //構造方法接收一個InvocationHandler對象爲參數，這個對象就是代理類的“直接委託類”（真正的委託類可以看做代理類的“間接委託類”）
  public $Proxy0(InvocationHandler var1) throws { 
    super（var1); 
  } 
  //對equals方法的調用實際上轉爲對super.h.invoke方法的調用，父類中的h即爲我們在構造方法中傳入的InvocationHandler對象，以下的toString()、sell()、ad()、hashCode()等方法同理 
  public final boolean equals(Object var1) throws { 
    try { 
      return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); 
    } catch (RuntimeException | Error var3) { 
      throw var3; 
    } catch (Throwable var4) { 
      throw new UndeclaredThrowableException(var4); 
    } 
  } 
  public final String toString() throws { 
    try { 
      return (String)super.h.invoke(this, m2, (Object[])null); 
    } catch (RuntimeException | Error var2) { 
      throw var2; 
    } catch (Throwable var3) { 
      throw new UndeclaredThrowableException(var3); 
    } 
  } 
  public final void ad() throws { 
    try { 
      super.h.invoke(this, m4, (Object[])null); 
    } catch (RuntimeException | Error var2) { 
      throw var2; 
    } catch (Throwable var3) { 
      throw new UndeclaredThrowableException(var3); 
    } 
  } 
  public final void sell() throws { 
    try { 
      super.h.invoke(this, m3, (Object[])null); 
    } catch (RuntimeException | Error var2) { 
      throw var2; 
    } catch (Throwable var3) { 
      throw new UndeclaredThrowableException(var3); 
    } 
  } 
  public final int hashCode() throws { 
    try { 
      return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue(); 
    } catch (RuntimeException | Error var2) { 
      throw var2; 
    } catch (Throwable var3) { 
      throw new UndeclaredThrowableException(var3); 
    } 
  } 
  //這裏完成Method對象的初始化（通過反射在運行時獲得Method對象） 
  static { 
    try { 
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")}); 
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); 
      m4 = Class.forName("Sell").getMethod("ad", new Class[0]); 
      m3 = Class.forName("Sell").getMethod("sell", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); 
    } catch (NoSuchMethodException var2) { 
      throw new NoSuchMethodError(var2.getMessage()); 
    } catch (ClassNotFoundException var3) { 
      throw new NoClassDefFoundError(var3.getMessage()); 
    } 
  }
}

我們可以看到，以上代碼的邏輯十分簡單，我們在註釋中也做出了相關的說明。（以上代碼中涉及到反射的使用，對於反射還不是很熟悉的小夥伴可以參考這裏：十分鐘理解Java之反射）

現在，我們已經瞭解了動態代理的使用，也搞清楚了它的實現原理，更進一步的話我們可以去了解動態代理類的生成過程，只需要去閱讀newProxyInstance方法的源碼即可，這個方法的邏輯也沒有複雜的地方，這裏就不展開了。感興趣的小夥伴可以自己去跟一下，也可以參考這篇文章：公共技術點之動態代理