詳解設計模式中的proxy代理模式及在Java程式中的實現_java

一、代理模式定義

給某個對象提供一個代理對象，並由代理對象控制對於原對象的訪問，即客戶不直接操控原對象，而是通過代理對象間接地操控原對象。
著名的代理模式的例子就是引用計數(reference counting): 當需要一個複雜物件的多份副本時， 代理模式可以結合享元模式以減少儲存空間的用量。典型做法是建立一個複雜物件以及多個代理者， 每個代理者會引用到原本的對象。而作用在代理者的運算會轉送到原本對象。一旦所有的代理者都不存在時， 複雜物件會被移除。

要理解代理模式很簡單，其實生活當中就存在代理模式：
我們購買火車票可以去火車站買，但是也可以去火車票代售處買，此處的火車票代售處就是火車站購票的代理，即我們在代售點發出買票請求，代售點會把請求發給火車站，火車站把購買成功響應發給代售點，代售點再告訴你。
但是代售點只能買票，不能退票，而火車站能買票也能退票，因此代理對象支援的操作可能和委派物件的操作有所不同。

再舉一個寫程式會碰到的一個例子：
如果現在有一個已有項目（你沒有原始碼，只能調用它）能夠調用 int compute(String exp1) 實現對於尾碼運算式的計算，你想使用這個項目實現對於中綴運算式的計算，那麼你可以寫一個代理類，並且其中也定義一個compute(String exp2)，這個exp2參數是中綴運算式，因此你需要在調用已有項目的 compute() 之前將中綴運算式轉換成尾碼運算式(Preprocess)，再調用已有項目的compute()，當然你還可以接收到傳回值之後再做些其他動作比如存入檔案(Postprocess)，這個過程就是使用了代理模式。

在平時用電腦也會碰到代理模式的應用：
遠程代理：我們在國內因為GFW，所以不能訪問 facebook，我們可以用翻牆（設定代理）的方法訪問。訪問過程是：
(1)使用者把HTTP請求發給代理
(2)代理把HTTP請求發給web伺服器
(3)web伺服器把HTTP響應發給代理
(4)代理把HTTP響應發回給使用者

二、靜態代理

所謂靜態代理， 就是在編譯階段就組建代理程式類來完成對代理對象的一系列操作。下面是代理模式的結構類圖：

1、代理模式的參與者

代理模式的角色分四種：

主題介面： 即代理類的所實現的行為介面。
目標對象： 也就是被代理的對象。
代理對象： 用來封裝真是主題類的代理類
用戶端
下面是代理模式的類圖結構：

2、代理模式的實現思路

代理對象和目標對象均實現同一個行為介面。
代理類和目標類分別具體實現介面邏輯。
在代理類的建構函式中執行個體化一個目標對象。
在代理類中調用目標對象的行為介面。
用戶端想要調用目標對象的行為介面，只能通過代理類來操作。
3、靜態代理的執行個體

下面以一個消極式載入的例子來說明一下靜態代理。我們在啟動某個服務系統時， 載入某一個類時可能會耗費很長時間。為了擷取更好的效能， 在啟動系統的時候， 我們往往不去初始化這個複雜的類， 取而代之的是去初始化其代理類。這樣將耗費資源多的方法使用代理進行分離， 可以加快系統的啟動速度， 減少使用者等待的時間。

定義一個主題介面

public interface Subject {  public void sayHello();  public void sayGoodBye();}

定義一個目標類, 並實現主題介面

public class RealSubject implements Subject {  public void sayHello() {    System.out.println("Hello World");  }  public void sayGoodBye() {    System.out.println("GoodBye World");  }}

定義一個代理類， 來代理目標對象。

public class StaticProxy implements Subject {  Private RealSubject realSubject = null;  public StaticProxy() {}  public void sayHello() {    //用到時候才載入， 懶載入    if(realSubject == null) {      realSubject = new RealSubject();    }    realSubject.sayHello();  }  //sayGoodbye方法同理  ...}

定義一個用戶端

public class Client {  public static void main(String [] args) {    StaticProxy sp = new StaticProxy();    sp.sayHello();    sp.sayGoodBye();  }}

以上就是靜態代理的一個簡單測試例子。感覺可能沒有實際用途。然而並非如此。使用代理我們還可以將目標對象的方法進行改造， 比如資料庫連接池中建立了一系列串連， 為了保證不頻繁的開啟串連，這些串連是幾乎不會關閉的。然而我們編程總有習慣去將開啟的Connection去close。 這樣我們就可以利用代理模式來重新代理Connection介面中的close方法， 改變為回收到資料庫連接池中而不是真正的執行Connection#close方法。其他的例子還有很多， 具體需要自己體會。

三、動態代理

動態代理是指在運行時動態組建代理程式類。即，代理類的位元組碼將在運行時產生並載入當前代理的 ClassLoader。與靜態處理類相比，動態類有諸多好處。

不需要為真實主題寫一個形式上完全一樣的封裝類，假如主題介面中的方法很多，為每一個介面寫一個代理方法也很麻煩。如果介面有變動，則真實主題和代理類都要修改，不利於系統維護；
使用一些動態代理的產生方法甚至可以在運行時制定代理類的執行邏輯，從而大大提升系統的靈活性。
產生動態代理的方法有很多： JDK中內建動態代理， CGlib, javassist等。這些方法各有優缺點。本文主要探究JDK中的動態代理的使用和源碼分析。

下面用一個執行個體講解一下JDK中動態代理的用法：

public class dynamicProxy implements InvocationHandler {  private RealSubject = null;  public Object invoke(Object proxy, Method method, Object[] args){    if(RealSubject == null) {      RealSubject = new RealSubject();    }    method.invoke(RealSubject, args);    return RealSubject;  }}

用戶端代碼執行個體

public class Client {  public static void main(Strings[] args) {    Subject subject = (Subject)Proxy.newInstance(ClassLoader.getSystemLoader(), RealSubject.class.getInterfaces(), new DynamicProxy());    Subject.sayHello();    Subject.sayGoodBye();  }}

從上面的代碼可以看出， 要利用JDK中的動態代理。利用靜態方法Proxy.newInstance(ClassLoader, Interfaces[], InvokeHandler)可以建立一個動態代理類。 newInstance方法有三個參數， 分別表示類載入器， 一個希望該代理類實現的介面列表， 以及實現InvokeHandler介面的執行個體。 動態代理將每個方法的執行過程則交給了Invoke方法處理。

JDK動態代理要求， 被代理的必須是個介面， 單純的類則不行。JDK動態代理所產生的代理類都會繼承Proxy類，同時代理類會實現所有你傳入的介面列表。因此可以強制類型轉換成介面類型。 下面是Proxy的結構圖。

可以看出Proxy全是靜態方法， 因此如果代理類沒有實現任何介面， 那麼他就是Proxy類型， 沒有執行個體方法。

當然加入你要是非要代理一個沒有實現某個介面的類， 同時該類的方法與其他介面定義的方法相同， 利用反射也是可以輕鬆實現的。

public class DynamicProxy implements InvokeHandler {  //你想代理的類  private TargetClass targetClass = null;  //初始化該類  public DynamicProxy(TargetClass targetClass) {    this.targetClass = targetClass;  }  public Object invoke(Object proxy, Method method, Object[] args) {    //利用反射擷取你想代理的類的方法    Method myMethod = targetClass.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());    myMethod.setAccessible(true);    return myMethod.invoke(targetClass, args);  }}

四、JDK動態代理源碼分析（JDK7）

看了上面的例子， 我們只是簡單會用動態代理。但是對於代理類是如何建立出來的， 是誰調用Invoke方法等還雲裡霧裡。下面通過分析

1、代理對象是如何建立出來的？

首先看Proxy.newInstance方法的源碼：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {  }  //擷取介面資訊  final Class<?>[] intfs = interfaces.clone();  final SecurityManager sm = System.getSecurityManager();  if (sm != null) {    checkProxyAccess(Reflection.getCallerClass(), loader, intfs);  }  //組建代理程式類  Class<?> cl = getProxyClass0(loader, intfs);  // ...OK我們先看前半截  }

從源碼看出代理類的產生是依靠getProxyClass0這個方法， 接下來看getProxyClass0源碼：

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {  //介面列表數目不能超過0xFFFF  if (interfaces.length > 65535) {    throw new IllegalArgumentException("interface limit exceeded");  }  //注意這裡, 下面詳細解釋     return proxyClassCache.get(loader, interfaces);  }

對proxyClassCache.get的解釋是： 如果實現介面列表的代理類已經存在，那麼直接從cache中拿。如果不存在， 則通過ProxyClassFactory產生一個。
在看proxyClassCache.get源碼之前，先簡單瞭解一下proxyClassCache：

 private static final WeakCache<ClassLoader, Class<?>[], Class<?>>    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

proxyClassCache是一個WeakCache類型的緩衝， 它的建構函式有兩個參數， 其中一個就是用於組建代理程式類的ProxyClassFactory， 下面是proxyClassCache.get的源碼：

final class WeakCache<K, P, V> {  ...  public V get(K key, P parameter) {}}

這裡K表示key， P表示parameters, V表示value

public V get(K key, P parameter) {  //java7 NullObject判斷方法， 如果parameter為空白則拋出帶有指定訊息的異常。 如果不為空白則返回。  Objects.requireNonNull(parameter);  //清理持有弱引用的WeakHashMap這種資料結構，一般用於緩衝  expungeStaleEntries();  //從隊列中擷取cacheKey  Object cacheKey = CacheKey.valueOf(key, refQueue);  //利用懶載入的方式填充Supplier， Concurrent是一種安全執行緒的map  ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);  if (valuesMap == null) {    ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());      if (oldValuesMap != null) {        valuesMap = oldValuesMap;      }    }    // create subKey and retrieve the possible Supplier<V> stored by that    // subKey from valuesMap  Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));  Supplier<V> supplier = valuesMap.get(subKey);  Factory factory = null;  while (true) {    if (supplier != null) {    // 從supplier中擷取Value，這個Value可能是一個工廠或者Cache的實    //下面這三句代碼是核心代碼， 返回實現InvokeHandler的類並包含了所需要的資訊。    V value = supplier.get();      if (value != null) {        return value;      }    }    // else no supplier in cache    // or a supplier that returned null (could be a cleared CacheValue    // or a Factory that wasn't successful in installing the CacheValue)    //下面這個過程就是填充supplier的過程    if(factory == null) {      //建立一個factory    }    if(supplier == null) {      //填充supplier    }else {      //填充supplier    }  }

while迴圈的作用就是不停的擷取實現InvokeHandler的類， 這個類可以是從緩衝中拿到，也可是是從proxyFactoryClass產生的。
Factory是一個實現了Supplier<V>介面的內部類。這個類覆蓋了get方法， 在get方法中調用了類型為proxyFactoryClass的執行個體方法apply。這個方法才是真正建立代理類的方法。下面看ProxyFactoryClass#apply方法的源碼：

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {  Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);  for (Class<?> intf : interfaces) {    /* Verify that the class loader resolves the name of this interface to the same Class object.*/  Class<?> interfaceClass = null;    try {      //載入每一個介面運行時的資訊      interfaceClass = Class.forName(intf.getName(), false, loader);    } catch (ClassNotFoundException e) {    }  //如果使用你自己的classload載入的class與你傳入的class不相等，拋出異常  if (interfaceClass != intf) {    throw new IllegalArgumentException(    intf + " is not visible from class loader");  }  //如果傳入不是一個介面類型    if (!interfaceClass.isInterface()) {      throw new IllegalArgumentException(        interfaceClass.getName() + " is not an interface");    }   //驗證介面是否重複    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {      throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());    }  }  String proxyPkg = null;   // package to define proxy class in  /* Record the package of a non-public proxy interface so that the proxy class will be defined in the same package.   * Verify that all non-public proxy interfaces are in the same package.  */  //這一段是看你傳入的介面中有沒有不是public的介面，如果有，這些介面必須全部在一個包裡定義的，否則拋異常   for (Class<?> intf : interfaces) {    int flags = intf.getModifiers();    if (!Modifier.isPublic(flags)) {      String name = intf.getName();      int n = name.lastIndexOf('.');      String pkg = ((n == -1) ? "" : name.substring(0, n + 1));      if (proxyPkg == null) {        proxyPkg = pkg;      } else if (!pkg.equals(proxyPkg)) {        throw new IllegalArgumentException(          "non-public interfaces from different packages");      }    }  }  if (proxyPkg == null) {    // if no non-public proxy interfaces, use com.sun.proxy package    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";  }  /*  * Choose a name for the proxy class to generate.  */  long num = nextUniqueNumber.getAndIncrement();  //產生隨機代理類的類名， $Proxy + num  String proxyName = proxyPkg + proxyClassNamePrefix + num;  /*  * 組建代理程式類的class檔案， 返回位元組流  */  byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);  try {    return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);  } catch (ClassFormatError e) {        //結束        throw new IllegalArgumentException(e.toString());      }    }  }

前文提到ProxyFactoryClass#apply是真正組建代理程式類的方法， 這其實是不準確的。原始碼讀到這裡，我們會發現ProxyGenerator#generateProxyClass才是真正組建代理程式類的方法。根據Java class位元組碼組成（可以參見我的另一篇文章Java位元組碼學習筆記）來產生相應的Clss檔案。具體ProxyGenerator#generateProxyClass源碼如下:

  private byte[] generateClassFile() {    /*     * Step 1: Assemble ProxyMethod objects for all methods to     * generate proxy dispatching code for.     */     //addProxyMethod方法，就是將方法都加入到一個列表中，並與對應的class對應起來     //這裡給Object對應了三個方法hashCode，toString和equals     addProxyMethod(hashCodeMethod, Object.class);    addProxyMethod(equalsMethod, Object.class);    addProxyMethod(toStringMethod, Object.class);    //將介面列表中的介面與介面下的方法對應起來    for (int i = 0; i < interfaces.length; i++) {      Method[] methods = interfaces[i].getMethods();      for (int j = 0; j < methods.length; j++) {        addProxyMethod(methods[j], interfaces[i]);      }    }    /*     * For each set of proxy methods with the same signature,     * verify that the methods' return types are compatible.     */    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {      checkReturnTypes(sigmethods);    }    /*     * Step 2: Assemble FieldInfo and MethodInfo structs for all of     * fields and methods in the class we are generating.     */     //方法中加入構造方法，這個構造方法只有一個，就是一個帶有InvocationHandler介面的構造方法      //這個才是真正給class檔案，也就是代理類加入方法了，不過還沒真正處理，只是先加進來等待迴圈，構造方法在class檔案中的名稱描述是<init>   try {    methods.add(generateConstructor());    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {      for (ProxyMethod pm : sigmethods) { //給每一個代理方法加一個Method類型的屬性，數字10是class檔案的標識符，代表這些屬性都是private static的         fields.add(new FieldInfo(pm.methodFieldName,          "Ljava/lang/reflect/Method;",           ACC_PRIVATE | ACC_STATIC));        //將每一個代理方法都加到代理類的方法中         methods.add(pm.generateMethod());      }    }  //加入一個靜態初始化塊，將每一個屬性都初始化，這裡靜態代碼塊也叫類構造方法，其實就是名稱為<clinit>的方法，所以加到方法列表       methods.add(generateStaticInitializer());    } catch (IOException e) {      throw new InternalError("unexpected I/O Exception");    }  //方法和屬性個數都不能超過65535，包括之前的介面個數也是這樣，   //這是因為在class檔案中，這些個數都是用4位16進位表示的，所以最大值是2的16次方-1     if (methods.size() > 65535) {      throw new IllegalArgumentException("method limit exceeded");    }    if (fields.size() > 65535) {      throw new IllegalArgumentException("field limit exceeded");    }  //接下來就是寫class檔案的過程， 包括魔數， 類名，常量池等一系列位元組碼的組成，就不一一細說了。需要的可以參考JVM虛擬機器位元組碼的相關知識。    cp.getClass(dotToSlash(className));    cp.getClass(superclassName);    for (int i = 0; i < interfaces.length; i++) {      cp.getClass(dotToSlash(interfaces[i].getName()));    }    cp.setReadOnly();    ByteArrayOutputStream bout = new ByteArrayOutputStream();    DataOutputStream dout = new DataOutputStream(bout);    try {                    // u4 magic;      dout.writeInt(0xCAFEBABE);                    // u2 minor_version;      dout.writeShort(CLASSFILE_MINOR_VERSION);                    // u2 major_version;      dout.writeShort(CLASSFILE_MAJOR_VERSION);      cp.write(dout);       // (write constant pool)                    // u2 access_flags;      dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);                    // u2 this_class;      dout.writeShort(cp.getClass(dotToSlash(className)));                    // u2 super_class;      dout.writeShort(cp.getClass(superclassName));                    // u2 interfaces_count;      dout.writeShort(interfaces.length);                    // u2 interfaces[interfaces_count];      for (int i = 0; i < interfaces.length; i++) {        dout.writeShort(cp.getClass(          dotToSlash(interfaces[i].getName())));      }                    // u2 fields_count;      dout.writeShort(fields.size());                    // field_info fields[fields_count];      for (FieldInfo f : fields) {        f.write(dout);      }                    // u2 methods_count;      dout.writeShort(methods.size());                    // method_info methods[methods_count];      for (MethodInfo m : methods) {        m.write(dout);      }                     // u2 attributes_count;      dout.writeShort(0); // (no ClassFile attributes for proxy classes)    } catch (IOException e) {      throw new InternalError("unexpected I/O Exception");    }    return bout.toByteArray();  }

經過層層調用， 一個代理類終於產生了。

2、是誰調用了Invoke?

我們類比JDK自己產生一個代理類, 類名為TestProxyGen：

public class TestGeneratorProxy {  public static void main(String[] args) throws IOException {    byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", Subject.class.getInterfaces());    File file = new File("/Users/yadoao/Desktop/TestProxyGen.class");    FileOutputStream fos = new FileOutputStream(file);     fos.write(classFile);     fos.flush();     fos.close();   }}

用JD-GUI反編譯該class檔案， 結果如下：

import com.su.dynamicProxy.ISubject;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class TestProxyGen extends Proxy implements ISubject{ private static Method m3; private static Method m1; private static Method m0; private static Method m4; private static Method m2; public TestProxyGen(InvocationHandler paramInvocationHandler)  throws  {  super(paramInvocationHandler); } public final void sayHello()  throws  {  try  {   this.h.invoke(this, m3, null);   return;  }  catch (Error|RuntimeException localError)  {   throw localError;  }  catch (Throwable localThrowable)  {   throw new UndeclaredThrowableException(localThrowable);  } } public final boolean equals(Object paramObject)  throws  {  try  {   return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  }  catch (Error|RuntimeException localError)  {   throw localError;  }  catch (Throwable localThrowable)  {   throw new UndeclaredThrowableException(localThrowable);  } } public final int hashCode()  throws  {  try  {   return ((Integer)this.h.invoke(this, m0, null)).intValue();  }  catch (Error|RuntimeException localError)  {   throw localError;  }  catch (Throwable localThrowable)  {   throw new UndeclaredThrowableException(localThrowable);  } } public final void sayGoodBye()  throws  {  try  {   this.h.invoke(this, m4, null);   return;  }  catch (Error|RuntimeException localError)  {   throw localError;  }  catch (Throwable localThrowable)  {   throw new UndeclaredThrowableException(localThrowable);  } } public final String toString()  throws  {  try  {   return (String)this.h.invoke(this, m2, null);  }  catch (Error|RuntimeException localError)  {   throw localError;  }  catch (Throwable localThrowable)  {   throw new UndeclaredThrowableException(localThrowable);  } } static {  try  {   m3 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayHello", new Class[0]);   m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });   m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);   m4 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayGoodBye", new Class[0]);   m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);   return;  }  catch (NoSuchMethodException localNoSuchMethodException)  {   throw new NoSuchMethodError(localNoSuchMethodException.getMessage());  }  catch (ClassNotFoundException localClassNotFoundException)  {   throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  } }}

首先注意到組建代理程式類的建構函式， 它傳入一個實現InvokeHandler介面的類作為參數， 並調用父類Proxy的構造器， 即將Proxy中的成員變數protected InvokeHander h進行了初始化。
再次注意到幾個靜態初始化塊， 這裡的靜態初始化塊就是對代理的介面列表以及hashcode,toString, equals方法進行初始化。
最後就是這幾個方法的調用過程， 全都是回調Invoke方法。
就此代理模式分析到此結束。