一、什麼是代理？
代理是一種常用的設計模式，其目的就是為其他物件提供一個代理以控制對某個物件的訪問。代理類負責為委託類預處理訊息，過濾訊息並轉發訊息，以及進行訊息被委託類執行後的後續處理。
代理模式UML圖：
為了保持行為的一致性，代理類和委託類通常會實現相同的介面，所以在訪問者看來兩者沒有絲毫的區別。通過代理類這中間一層，能有效控制對委託類物件的直接訪問，也可以很好地隱藏和保護委託類物件，同時也為實施不同控制策略預留了空間，從而在設計上獲得了更大的靈活性。Java 動態代理機制以巧妙的方式近乎完美地實踐了代理模式的設計理念。
二、Java 動態代理類
Java動態代理類位於java.lang.reflect包下，一般主要涉及到以下兩個類：
(1)Interface InvocationHandler：該介面中僅定義了一個方法
- publicobject invoke(Object obj,Method method, Object[] args)
在實際使用時，第一個引數obj一般是指代理類，method是被代理的方法，如上例中的request()，args為該方法的引數陣列。這個抽象方法在代理類中動態實現。
(2)Proxy：該類即為動態代理類，其中主要包含以下內容：
protected Proxy(InvocationHandler h)：建構函式，用於給內部的h賦值。
static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：獲得一個代理類，其中loader是類裝載器，interfaces是真實類所擁有的全部介面的陣列。
static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理類的一個例項，返回後的代理類可以當作被代理類使用(可使用被代理類的在Subject介面中宣告過的方法)
所謂DynamicProxy是這樣一種class：它是在執行時生成的class，在生成它時你必須提供一組interface給它，然後該class就宣稱它實現了這些interface。你當然可以把該class的例項當作這些interface中的任何一個來用。當然，這個DynamicProxy其實就是一個Proxy，它不會替你作實質性的工作，在生成它的例項時你必須提供一個handler，由它接管實際的工作。
在使用動態代理類時，我們必須實現InvocationHandler介面
通過這種方式，被代理的物件(RealSubject)可以在執行時動態改變，需要控制的介面(Subject介面)可以在執行時改變，控制的方式(DynamicSubject類)也可以動態改變，從而實現了非常靈活的動態代理關係。
動態代理步驟：
1.建立一個實現介面InvocationHandler的類，它必須實現invoke方法
2.建立被代理的類以及介面
3.通過Proxy的靜態方法
newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)建立一個代理
4.通過代理呼叫方法
三、JDK的動態代理怎麼使用？
1、需要動態代理的介面：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package jiankunking; /** * 需要動態代理的介面 */ public interface Subject { /** * 你好 * * @param name * @return */ public String SayHello(String name); /** * 再見 * * @return */ public String SayGoodBye(); } |
2、需要代理的實際物件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package jiankunking; /** * 實際物件 */ public class RealSubject implements Subject { /** * 你好 * * @param name * @return */ public String SayHello(String name) { return "hello " + name; } /** * 再見 * * @return */ public String SayGoodBye() { return " good bye "; } } |
3、呼叫處理器實現類
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
package jiankunking; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * 呼叫處理器實現類 * 每次生成動態代理類物件時都需要指定一個實現了該介面的呼叫處理器物件 */ public class InvocationHandlerImpl implements InvocationHandler { /** * 這個就是我們要代理的真實物件 */ private Object subject; /** * 構造方法，給我們要代理的真實物件賦初值 * * @param subject */ public InvocationHandlerImpl(Object subject) { this.subject = subject; } /** * 該方法負責集中處理動態代理類上的所有方法呼叫。 * 呼叫處理器根據這三個引數進行預處理或分派到委託類例項上反射執行 * * @param proxy 代理類例項 * @param method 被呼叫的方法物件 * @param args 呼叫引數 * @return * @throws Throwable */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //在代理真實物件前我們可以新增一些自己的操作 System.out.println("在呼叫之前，我要乾點啥呢？"); System.out.println("Method:" + method); //當代理物件呼叫真實物件的方法時，其會自動的跳轉到代理物件關聯的handler物件的invoke方法來進行呼叫 Object returnValue = method.invoke(subject, args); //在代理真實物件後我們也可以新增一些自己的操作 System.out.println("在呼叫之後，我要乾點啥呢？"); return returnValue; } } |
4、測試
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
package jiankunking; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * 動態代理演示 */ public class DynamicProxyDemonstration { public static void main(String[] args) { //代理的真實物件 Subject realSubject = new RealSubject(); /** * InvocationHandlerImpl 實現了 InvocationHandler 介面，並能實現方法呼叫從代理類到委託類的分派轉發 * 其內部通常包含指向委託類例項的引用，用於真正執行分派轉發過來的方法呼叫. * 即：要代理哪個真實物件，就將該物件傳進去，最後是通過該真實物件來呼叫其方法 */ InvocationHandler handler = new InvocationHandlerImpl(realSubject); ClassLoader loader = realSubject.getClass().getClassLoader(); Class[] interfaces = realSubject.getClass().getInterfaces(); /** * 該方法用於為指定類裝載器、一組介面及呼叫處理器生成動態代理類例項 */ Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler); System.out.println("動態代理物件的型別："+subject.getClass().getName()); String hello = subject.SayHello("jiankunking"); System.out.println(hello); // String goodbye = subject.SayGoodBye(); // System.out.println(goodbye); } } |
5、輸出結果如下：
演示demo下載地址：http://download.csdn.net/detail/xunzaosiyecao/9597388
四、動態代理怎麼實現的？
從使用程式碼中可以看出，關鍵點在：
|
1 |
Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler); |
通過跟蹤提示程式碼可以看出：當代理物件呼叫真實物件的方法時，其會自動的跳轉到代理物件關聯的handler物件的invoke方法來進行呼叫。
也就是說，當程式碼執行到：
subject.SayHello(“jiankunking”)這句話時，會自動呼叫InvocationHandlerImpl的invoke方法。這是為啥呢？
======橫線之間的是程式碼跟分析的過程，不想看的朋友可以直接看結論======
以下程式碼來自:JDK1.8.0_92
既然生成代理物件是用的Proxy類的靜態方newProxyInstance，那麼我們就去它的原始碼裡看一下它到底都做了些什麼？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
public static Object newProxyInstance(ClassLoader loader, Class>[] interfaces, InvocationHandler h) throws IllegalArgumentException { //檢查h 不為空，否則拋異常 Objects.requireNonNull(h); final Class>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /* * 獲得與指定類裝載器和一組介面相關的代理類型別物件 */ Class> cl = getProxyClass0(loader, intfs); /* * 通過反射獲取建構函式物件並生成代理類例項 */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } //獲取代理物件的構造方法（也就是$Proxy0(InvocationHandler h)） final Constructor> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction() { public Void run() { cons.setAccessible(true); return null; } }); } //生成代理類的例項並把InvocationHandlerImpl的例項傳給它的構造方法 return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } } |
我們再進去getProxyClass0方法看一下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/** * Generate a proxy class. Must call the checkProxyAccess method * to perform permission checks before calling this. */ private static Class> getProxyClass0(ClassLoader loader, Class>... interfaces) { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // If the proxy class defined by the given loader implementing // the given interfaces exists, this will simply return the cached copy; // otherwise, it will create the proxy class via the ProxyClassFactory return proxyClassCache.get(loader, interfaces); } |
真相還是沒有來到，繼續，看一下proxyClassCache
|
1 2 3 4 5 |
/** * a cache of proxy classes */ private static final WeakCache[], Class>> proxyClassCache = new WeakCache(new KeyFactory(), new ProxyClassFactory()); |
奧，原來用了一下快取啊
那麼它對應的get方法啥樣呢？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
/** * Look-up the value through the cache. This always evaluates the * {code subKeyFactory} function and optionally evaluates * {code valueFactory} function if there is no entry in the cache for given * pair of (key, subKey) or the entry has already been cleared. * * @param key possibly null key * @param parameter parameter used together with key to create sub-key and * value (should not be null) * @return the cached value (never null) * @throws NullPointerException if {code parameter} passed in or * {code sub-key} calculated by * {code subKeyFactory} or {code value} * calculated by {code valueFactory} is null. */ public V get(K key, P parameter) { Objects.requireNonNull(parameter); expungeStaleEntries(); Object cacheKey = CacheKey.valueOf(key, refQueue); // lazily install the 2nd level valuesMap for the particular cacheKey ConcurrentMap> valuesMap = map.get(cacheKey); if (valuesMap == null) { //putIfAbsent這個方法在key不存在的時候加入一個值,如果key存在就不放入 ConcurrentMap> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap()); if (oldValuesMap != null) { valuesMap = oldValuesMap; } } // create subKey and retrieve the possible Supplier stored by that // subKey from valuesMap Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier supplier = valuesMap.get(subKey); Factory factory = null; while (true) { if (supplier != null) { // supplier might be a Factory or a CacheValue instance 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) // lazily construct a Factory if (factory == null) { factory = new Factory(key, parameter, subKey, valuesMap); } if (supplier == null) { supplier = valuesMap.putIfAbsent(subKey, factory); if (supplier == null) { // successfully installed Factory supplier = factory; } // else retry with winning supplier } else { if (valuesMap.replace(subKey, supplier, factory)) { // successfully replaced // cleared CacheEntry / unsuccessful Factory // with our Factory supplier = factory; } else { // retry with current supplier supplier = valuesMap.get(subKey); } } } } |
我們可以看到它呼叫了 supplier.get(); 獲取動態代理類，其中supplier是Factory,這個類定義在WeakCach的內部。
來瞅瞅，get裡面又做了什麼？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
public synchronized V get() { // serialize access // re-check Supplier supplier = valuesMap.get(subKey); if (supplier != this) { // something changed while we were waiting: // might be that we were replaced by a CacheValue // or were removed because of failure -> // return null to signal WeakCache.get() to retry // the loop return null; } // else still us (supplier == this) // create new value V value = null; try { value = Objects.requireNonNull(valueFactory.apply(key, parameter)); } finally { if (value == null) { // remove us on failure valuesMap.remove(subKey, this); } } // the only path to reach here is with non-null value assert value != null; // wrap value with CacheValue (WeakReference) CacheValue cacheValue = new CacheValue(value); // try replacing us with CacheValue (this should always succeed) if (valuesMap.replace(subKey, this, cacheValue)) { // put also in reverseMap reverseMap.put(cacheValue, Boolean.TRUE); } else { throw new AssertionError("Should not reach here"); } // successfully replaced us with new CacheValue -> return the value // wrapped by it return value; } } |
發現重點還是木有出現，但我們可以看到它呼叫了valueFactory.apply(key, parameter)方法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 |
/** * A factory function that generates, defines and returns the proxy class given * the ClassLoader and array of interfaces. */ private static final class ProxyClassFactory implements BiFunction[], Class>> { // prefix for all proxy class names private static final String proxyClassNamePrefix = "$Proxy"; // next number to use for generation of unique proxy class names private static final AtomicLong nextUniqueNumber = new AtomicLong(); @Override public Class> apply(ClassLoader loader, Class>[] interfaces) { Map, 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) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } /* * Verify that the Class object actually represents an * interface. */ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /* * Verify that this interface is not a duplicate. */ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } String proxyPkg = null; // package to define proxy class in int accessFlags = Modifier.PUBLIC | Modifier.FINAL; /* * 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. */ for (Class> intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { accessFlags = Modifier.FINAL; 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(); String proxyName = proxyPkg + proxyClassNamePrefix + num; /* * Generate the specified proxy class. */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { /* * A ClassFormatError here means that (barring bugs in the * proxy class generation code) there was some other * invalid aspect of the arguments supplied to the proxy * class creation (such as virtual machine limitations * exceeded). */ throw new IllegalArgumentException(e.toString()); } } } |
通過看程式碼終於找到了重點：
|
1 2 |
//生成位元組碼 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); |
那麼接下來我們也使用測試一下，使用這個方法生成的位元組碼是個什麼樣子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
package jiankunking; import sun.misc.ProxyGenerator; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * 動態代理演示 */ public class DynamicProxyDemonstration { public static void main(String[] args) { //代理的真實物件 Subject realSubject = new RealSubject(); /** * InvocationHandlerImpl 實現了 InvocationHandler 介面，並能實現方法呼叫從代理類到委託類的分派轉發 * 其內部通常包含指向委託類例項的引用，用於真正執行分派轉發過來的方法呼叫. * 即：要代理哪個真實物件，就將該物件傳進去，最後是通過該真實物件來呼叫其方法 */ InvocationHandler handler = new InvocationHandlerImpl(realSubject); ClassLoader loader = handler.getClass().getClassLoader(); Class[] interfaces = realSubject.getClass().getInterfaces(); /** * 該方法用於為指定類裝載器、一組介面及呼叫處理器生成動態代理類例項 */ Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler); System.out.println("動態代理物件的型別："+subject.getClass().getName()); String hello = subject.SayHello("jiankunking"); System.out.println(hello); // 將生成的位元組碼儲存到本地， createProxyClassFile(); } private static void createProxyClassFile(){ String name = "ProxySubject"; byte[] data = ProxyGenerator.generateProxyClass(name,new Class[]{Subject.class}); FileOutputStream out =null; try { out = new FileOutputStream(name+".class"); System.out.println((new File("hello")).getAbsolutePath()); out.write(data); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally { if(null!=out) try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } } |
我們用jd-jui 工具將生成的位元組碼反編譯：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; import jiankunking.Subject; public final class ProxySubject extends Proxy implements Subject { private static Method m1; private static Method m3; private static Method m4; private static Method m2; private static Method m0; public ProxySubject(InvocationHandler paramInvocationHandler) { super(paramInvocationHandler); } public final boolean equals(Object paramObject) { 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 String SayGoodBye() { try { return (String)this.h.invoke(this, m3, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String SayHello(String paramString) { try { return (String)this.h.invoke(this, m4, new Object[] { paramString }); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String toString() { try { return (String)this.h.invoke(this, m2, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final int hashCode() { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]); m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] { Class.forName("java.lang.String") }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } } } |
這就是最終真正的代理類，它繼承自Proxy並實現了我們定義的Subject介面
也就是說：
|
1 |
Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler); |
這裡的subject實際是這個類的一個例項，那麼我們呼叫它的：
|
1 |
public final String SayHello(String paramString) |
就是呼叫我們定義的InvocationHandlerImpl的 invoke方法：
======橫線之間的是程式碼跟分析的過程，不想看的朋友可以直接看結論=======
五、結論
到了這裡，終於解答了：
subject.SayHello(“jiankunking”)這句話時，為什麼會自動呼叫InvocationHandlerImpl的invoke方法？
因為JDK生成的最終真正的代理類，它繼承自Proxy並實現了我們定義的Subject介面，在實現Subject介面方法的內部，通過反射呼叫了InvocationHandlerImpl的invoke方法。
包含生成本地class檔案的demo：http://download.csdn.net/detail/xunzaosiyecao/9597474
通過分析程式碼可以看出Java 動態代理，具體有如下四步驟：
- 通過實現 InvocationHandler 介面建立自己的呼叫處理器；
- 通過為 Proxy 類指定 ClassLoader 物件和一組 interface 來建立動態代理類；
- 通過反射機制獲得動態代理類的建構函式，其唯一引數型別是呼叫處理器介面型別；
- 通過建構函式建立動態代理類例項，構造時呼叫處理器物件作為引數被傳入。