1 代理概念

為某個物件提供一個代理，以控制對這個物件的訪問。 代理類和委託類有共同的父類或父介面，這樣在任何使用委託類物件的地方都可以用代理物件替代。代理類負責請求的預處理、過濾、將請求分派給委託類處理、以及委託類執行完請求後的後續處理。

代理模式圖

從圖中可以看出，代理介面（Subject）、代理類（ProxySubject）、委託類（RealSubject）形成一個“品”字結構。 根據代理類的生成時間不同可以將代理分為靜態代理和動態代理兩種。

下面以一個模擬需求說明靜態代理和動態代理：委託類要處理一項耗時較長的任務，客戶類需要打印出執行任務消耗的時間。解決這個問題需要記錄任務執行前時間和任務執行後時間，兩個時間差就是任務執行消耗的時間。

2 靜態代理

由程式設計師建立或工具生成代理類的原始碼，再編譯代理類。所謂靜態也就是在程式執行前就已經存在代理類的位元組碼檔案，代理類和委託類的關係在執行前就確定了。

清單1：代理介面

Java程式碼

/**  
     * 代理介面。處理給定名字的任務。 
     */  
    public interface Subject {  
      /** 
       * 執行給定名字的任務。 
        * @param taskName 任務名 
       */  
       public void dealTask(String taskName);   
    }  
 

清單2：委託類，具體處理業務。

Java程式碼

/** 
     * 真正執行任務的類，實現了代理介面。 
     */  
    public class RealSubject implements Subject {  

     /** 
      * 執行給定名字的任務。這裡打印出任務名，並休眠500ms模擬任務執行了很長時間 
      * @param taskName  
      */  
       @Override  
       public void dealTask(String taskName) {  
          System.out.println("正在執行任務："
 
+taskName);  
          try {  
             Thread.sleep(500);  
          } catch (InterruptedException e) {  
             e.printStackTrace();  
          }  
       }  
    }  

清單3：靜態代理類

Java程式碼

/** 
     *　代理類，實現了代理介面。 
     */  
    public class ProxySubject implements Subject {  
     //代理類持有一個委託類的物件引用  
     private Subject delegate;  

     public ProxySubject(Subject delegate) {  
      this.delegate = delegate;  
     }  

     /** 
      * 將請求分派給委託類執行，記錄任務執行前後的時間，時間差即為任務的處理時間 
      *  
      * @param taskName 
      */  
     @Override  
     public void dealTask(String taskName) {  
      long stime = System.currentTimeMillis();   
      //將請求分派給委託類處理  
      delegate.dealTask(taskName);  
      long ftime = System.currentTimeMillis();   
      System.out.println("執行任務耗時"+(ftime - stime)+"毫秒");  

     }  
    }  

清單4：生成靜態代理類工廠

Java程式碼

    public class SubjectStaticFactory {  
     //客戶類呼叫此工廠方法獲得代理物件。  
     //對客戶類來說，其並不知道返回的是代理類物件還是委託類物件。  
     public static Subject getInstance(){   
      return new ProxySubject(new RealSubject());  
     }  
    }  

清單5：客戶類

Java程式碼

public class Client1 {  

     public static void main(String[] args) {  
          Subject proxy = SubjectStaticFactory.getInstance();  
          proxy.dealTask("DBQueryTask");  
     }   

   }  

靜態代理類優缺點 ：

優點：業務類只需要關注業務邏輯本身，保證了業務類的重用性。這是代理的共有優點。

缺點：

• 代理物件的一個介面只服務於一種型別的物件，如果要代理的方法很多，勢必要為每一種方法都進行代理，靜態代理在程式規模稍大時就無法勝任了。
• 如果介面增加一個方法，除了所有實現類需要實現這個方法外，所有代理類也需要實現此方法。增加了程式碼維護的複雜度。

3 動態代理

動態代理類的原始碼是在程式執行期間由JVM根據反射等機制動態的生成，所以不存在代理類的位元組碼檔案。代理類和委託類的關係是在程式執行時確定。

1、先看看與動態代理緊密關聯的Java API。

1）java.lang.reflect.Proxy

這是 Java 動態代理機制生成的所有動態代理類的父類，它提供了一組靜態方法來為一組介面動態地生成代理類及其物件。

清單6：Proxy類的靜態方法

Java程式碼

// 方法 1: 該方法用於獲取指定代理物件所關聯的呼叫處理器  
static InvocationHandler getInvocationHandler(Object proxy)

// 方法 2：該方法用於獲取關聯於指定類裝載器和一組介面的動態代理類的類物件  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   

// 方法 3：該方法用於判斷指定類物件是否是一個動態代理類  
static boolean isProxyClass(Class cl)   

// 方法 4：該方法用於為指定類裝載器、一組介面及呼叫處理器生成動態代理類例項  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)   

2）java.lang.reflect.InvocationHandler

這是呼叫處理器介面，它自定義了一個 invoke 方法，用於集中處理在動態代理類物件上的方法呼叫，通常在該方法中實現對委託類的代理訪問。每次生成動態代理類物件時都要指定一個對應的呼叫處理器物件。

清單7：InvocationHandler的核心方法

Java程式碼

  // 該方法負責集中處理動態代理類上的所有方法呼叫。
  //第一個引數既是代理類例項，
  //第二個引數是被呼叫的方法物件  
  // 第三個方法是呼叫引數。呼叫處理器根據這三個引數進行預處理或分派到委託類例項上反射執行  
  Object invoke(Object proxy, Method method, Object[] args)   

3）java.lang.ClassLoader

這是類裝載器類，負責將類的位元組碼裝載到 Java 虛擬機器（JVM）中併為其定義類物件，然後該類才能被使用。Proxy 靜態方法生成動態代理類同樣需要通過類裝載器來進行裝載才能使用，它與普通類的唯一區別就是其位元組碼是由 JVM 在執行時動態生成的而非預存在於任何一個 .class 檔案中。

每次生成動態代理類物件時都需要指定一個類裝載器物件

2、動態代理實現步驟

具體步驟是：

• a. 實現InvocationHandler介面建立自己的呼叫處理器
• b. 給Proxy類提供ClassLoader和代理介面型別陣列建立動態代理類
• c. 以呼叫處理器型別為引數，利用反射機制得到動態代理類的建構函式
• d. 以呼叫處理器物件為引數，利用動態代理類的建構函式建立動態代理類物件

清單8：分步驟實現動態代理

Java程式碼

// InvocationHandlerImpl 實現了 InvocationHandler 介面，並能實現方法呼叫從代理類到委託類的分派轉發  
// 其內部通常包含指向委託類例項的引用，用於真正執行分派轉發過來的方法呼叫  
InvocationHandler handler = new InvocationHandlerImpl(..);   

// 通過 Proxy 為包括 Interface 介面在內的一組介面動態建立代理類的類物件  
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });   

// 通過反射從生成的類物件獲得建構函式物件  
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });   

// 通過建構函式物件建立動態代理類例項  
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });   

Proxy類的靜態方法newProxyInstance對上面具體步驟的後三步做了封裝，簡化了動態代理物件的獲取過程。

清單9：簡化後的動態代理實現

Java程式碼

// InvocationHandlerImpl 實現了 InvocationHandler 介面，並能實現方法呼叫從代理類到委託類的分派轉發  
InvocationHandler handler = new InvocationHandlerImpl(..);   

// 通過 Proxy 直接建立動態代理類例項  
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,   
     new Class[] { Interface.class },  handler );   

3、動態代理實現示例

清單10：建立自己的呼叫處理器

Java程式碼

/** 
 * 動態代理類對應的呼叫處理程式類 
 */  
public class SubjectInvocationHandler implements InvocationHandler {  

 //代理類持有一個委託類的物件引用  
 private Object delegate;  

 public SubjectInvocationHandler(Object delegate) {  
      this.delegate = delegate;  
 }  

 @Override  
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
      long stime = System.currentTimeMillis();   
      //利用反射機制將請求分派給委託類處理。Method的invoke返回Object物件作為方法執行結果。  
      //因為示例程式沒有返回值，所以這裡忽略了返回值處理  
      method.invoke(delegate, args);  
      long ftime = System.currentTimeMillis();   
      System.out.println("執行任務耗時"+(ftime - stime)+"毫秒");  

      return null;  
 }  
}   

清單11：生成動態代理物件的工廠，工廠方法列出瞭如何生成動態代理類物件的步驟。

Java程式碼

/** 
 * 生成動態代理物件的工廠. 
 */  
public class DynProxyFactory {  
 //客戶類呼叫此工廠方法獲得代理物件。  
 //對客戶類來說，其並不知道返回的是代理類物件還是委託類物件。  
 public static Subject getInstance(){   
  Subject delegate = new RealSubject();  
  InvocationHandler handler = new SubjectInvocationHandler(delegate);  
  Subject proxy = null;  
  proxy = (Subject)Proxy.newProxyInstance(  
    delegate.getClass().getClassLoader(),   
    delegate.getClass().getInterfaces(),   
    handler);  
  return proxy;  
 }  
}  

清單12：動態代理客戶類

Java程式碼

public class Client {  

 public static void main(String[] args) {  

  Subject proxy = DynProxyFactory.getInstance();  
  proxy.dealTask("DBQueryTask");  
 }   

}  

動態代理的優點和美中不足

• 優點：
  動態代理與靜態代理相比較，最大的好處是介面中宣告的所有方法都被轉移到呼叫處理器一個集中的方法中處理（InvocationHandler.invoke）。這樣，在介面方法數量比較多的時候，我們可以進行靈活處理，而不需要像靜態代理那樣每一個方法進行中轉。在本示例中看不出來，因為invoke方法體內嵌入了具體的外圍業務（記錄任務處理前後時間並計算時間差），實際中可以類似Spring AOP那樣配置外圍業務。

• 美中不足：
  誠然，Proxy 已經設計得非常優美，但是還是有一點點小小的遺憾之處，那就是它始終無法擺脫僅支援 interface 代理的桎梏，因為它的設計註定了這個遺憾。回想一下那些動態生成的代理類的繼承關係圖，它們已經註定有一個共同的父類叫 Proxy。Java 的繼承機制註定了這些動態代理類們無法實現對 class 的動態代理，原因是多繼承在 Java 中本質上就行不通。