## [動態代理](https://lingcoder.gitee.io/onjava8/#/book/19-Type-Information?id=%e5%8a%a8%e6%80%81%e4%bb%a3%e7%90%86) *代理*是基本的設計模式之一。一個對象封裝真實對象，代替其提供其他或不同的操作---這些操作通常涉及到與“真實”對象的通信，因此代理通常充當中間對象。這是一個簡單的示例，顯示代理的結構： ~~~ // typeinfo/SimpleProxyDemo.java interface Interface { void doSomething(); void somethingElse(String arg); } class RealObject implements Interface { @Override public void doSomething() { System.out.println("doSomething"); } @Override public void somethingElse(String arg) { System.out.println("somethingElse " + arg); } } class SimpleProxy implements Interface { private Interface proxied; SimpleProxy(Interface proxied) { this.proxied = proxied; } @Override public void doSomething() { System.out.println("SimpleProxy doSomething"); proxied.doSomething(); } @Override public void somethingElse(String arg) { System.out.println( "SimpleProxy somethingElse " + arg); proxied.somethingElse(arg); } } class SimpleProxyDemo { public static void consumer(Interface iface) { iface.doSomething(); iface.somethingElse("bonobo"); } public static void main(String[] args) { consumer(new RealObject()); consumer(new SimpleProxy(new RealObject())); } } ~~~ 輸出結果： ~~~ doSomething somethingElse bonobo SimpleProxy doSomething doSomething SimpleProxy somethingElse bonobo somethingElse bonobo ~~~ 因為`consumer()`接受`Interface`，所以它不知道獲得的是`RealObject`還是`SimpleProxy`，因為兩者都實現了`Interface`。 但是，在客戶端和`RealObject`之間插入的`SimpleProxy`執行操作，然后在`RealObject`上調用相同的方法。 當你希望將額外的操作與“真實對象”做分離時，代理可能會有所幫助，尤其是當你想要輕松地啟用額外的操作時，反之亦然（設計模式就是封裝變更---所以你必須改變一些東西以證明模式的合理性）。例如，如果你想跟蹤對`RealObject`中方法的調用，或衡量此類調用的開銷，該怎么辦？你不想這部分代碼耦合到你的程序中，而代理能使你可以很輕松地添加或刪除它。 Java 的*動態代理*更進一步，不僅動態創建代理對象而且動態處理對代理方法的調用。在動態代理上進行的所有調用都被重定向到單個*調用處理程序*，該處理程序負責發現調用的內容并決定如何處理。這是`SimpleProxyDemo.java`使用動態代理重寫的例子： ~~~ // typeinfo/SimpleDynamicProxy.java import java.lang.reflect.*; class DynamicProxyHandler implements InvocationHandler { private Object proxied; DynamicProxyHandler(Object proxied) { this.proxied = proxied; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println( "**** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args); if (args != null) for (Object arg : args) System.out.println(" " + arg); return method.invoke(proxied, args); } } class SimpleDynamicProxy { public static void consumer(Interface iface) { iface.doSomething(); iface.somethingElse("bonobo"); } public static void main(String[] args) { RealObject real = new RealObject(); consumer(real); // Insert a proxy and call again: Interface proxy = (Interface) Proxy.newProxyInstance( Interface.class.getClassLoader(), new Class[]{Interface.class}, new DynamicProxyHandler(real)); consumer(proxy); } } ~~~ 輸出結果： ~~~ doSomething somethingElse bonobo **** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null doSomething **** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@6bc7c054 bonobo somethingElse bonobo ~~~ 可以通過調用靜態方法`Proxy.newProxyInstance()`來創建動態代理，該方法需要一個類加載器（通常可以從已加載的對象中獲取），希望代理實現的接口列表（不是類或抽象類），以及接口`InvocationHandler`的一個實現。動態代理會將所有調用重定向到調用處理程序，因此通常為調用處理程序的構造函數提供對“真實”對象的引用，以便一旦執行中介任務便可以轉發請求。 `invoke()`方法被傳遞給代理對象，以防萬一你必須區分請求的來源---但是在很多情況下都無需關心。但是，在`invoke()`內的代理上調用方法時要小心，因為接口的調用是通過代理重定向的。 通常執行代理操作，然后使用`Method.invoke()`將請求轉發給被代理對象，并攜帶必要的參數。這在一開始看起來是有限制的，好像你只能執行一般的操作。但是，可以過濾某些方法調用，同時傳遞其他方法調用： ~~~ // typeinfo/SelectingMethods.java // Looking for particular methods in a dynamic proxy import java.lang.reflect.*; class MethodSelector implements InvocationHandler { private Object proxied; MethodSelector(Object proxied) { this.proxied = proxied; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getName().equals("interesting")) System.out.println( "Proxy detected the interesting method"); return method.invoke(proxied, args); } } interface SomeMethods { void boring1(); void boring2(); void interesting(String arg); void boring3(); } class Implementation implements SomeMethods { @Override public void boring1() { System.out.println("boring1"); } @Override public void boring2() { System.out.println("boring2"); } @Override public void interesting(String arg) { System.out.println("interesting " + arg); } @Override public void boring3() { System.out.println("boring3"); } } class SelectingMethods { public static void main(String[] args) { SomeMethods proxy = (SomeMethods) Proxy.newProxyInstance( SomeMethods.class.getClassLoader(), new Class[]{ SomeMethods.class }, new MethodSelector(new Implementation())); proxy.boring1(); proxy.boring2(); proxy.interesting("bonobo"); proxy.boring3(); } } ~~~ 輸出結果： ~~~ boring1 boring2 Proxy detected the interesting method interesting bonobo boring3 ~~~ 在這個示例里，我們只是在尋找方法名，但是你也可以尋找方法簽名的其他方面，甚至可以搜索特定的參數值。 動態代理不是你每天都會使用的工具，但是它可以很好地解決某些類型的問題。你可以在 Erich Gamma 等人的*設計模式*中了解有關*代理*和其他設計模式的更多信息。 （Addison-Wesley，1995年），以及[設計模式](https://lingcoder.gitee.io/onjava8/#/./25-Patterns)一章。