相比于靜態代理，動態代理避免了開發人員編寫各個繁鎖的靜態代理類，只需簡單地指定一組接口及目標類對象就能動態的獲得代理對象。動態代理類的源碼是在程序運行期間由JVM根據反射等機制動態的生成，所以不存在代理類的字節碼文件。代理類和委托類的關系是在程序運行時確定。 關于JDK的動態代理，最為人熟知的可能要數spring AOP的實現，默認情況下，Spring AOP的實現對于接口來說就是使用的JDK的動態代理來實現的，而對于類的代理使用CGLIB來實現。

1、代理模式

使用代理模式必須要讓代理類和目標類實現相同的接口，客戶端通過代理類來調用目標方法，代理類會將所有的方法調用分派到目標對象上反射執行，還可以在分派過程中添加”前置通知”和后置處理（如在調用目標方法前校驗權限，在調用完目標方法后打印日志等）等功能。

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

1）java.lang.reflect.Proxy
這是 Java 動態代理機制生成的所有動態代理類的父類，它提供了一組靜態方法來為一組接口動態地生成代理類及其對象。

Proxy類的靜態方法 // 方法 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 方法，用于集中處理在動態代理類對象上的方法調用，通常在該方法中實現對委托類的代理訪問。每次生成動態代理類對象時都要指定一個對應的調用處理器對象。

InvocationHandler的核心方法 // 該方法負責集中處理動態代理類上的所有方法調用。第一個參數既是代理類實例，第二個參數是被調用的方法對象 // 第三個方法是調用參數。調用處理器根據這三個參數進行預處理或分派到委托類實例上反射執行 Object invoke(Object proxy, Method method, Object[] args)

3）java.lang.ClassLoader
這是類裝載器類，負責將類的字節碼裝載到 Java 虛擬機（JVM）中并為其定義類對象，然后該類才能被使用。Proxy 靜態方法生成動態代理類同樣需要通過類裝載器來進行裝載才能使用，它與普通類的唯一區別就是其字節碼是由 JVM 在運行時動態生成的而非預存在于任何一個 .class 文件中。每次生成動態代理類對象時都需要指定一個類裝載器對象。

3、使用動態代理的五大步驟

1).通過實現InvocationHandler接口來自定義自己的InvocationHandler;
自定義InvocationHandler中有一個目標對象作為變量；一個目標對象作為入參的構造方法；invoke方法；
在動態代理中InvocationHandler是核心，每個代理實例都具有一個關聯的InvocationHandler(調用處理程序)。當代理實例調用方法時，將對方法調用進行編碼并將其指派到它的InvocationHandler(調用處理程序)的 invoke 方法。所以對代理方法的調用都是通InvocationHadler的invoke來實現中，而invoke方法根據傳入的代理對象，方法和參數來決定調用代理的哪個方法。invoke方法簽名：invoke（Object Proxy，Method method，Object[] args）

2).通過Proxy.getProxyClass獲得動態代理類

3).使用得到的動態代理類通過反射機制獲得代理類的構造方法，方法簽名為getConstructor(InvocationHandler.class)

4).通過構造函數來創建動態代理對象，并將自定義的InvocationHandler實例對象傳為參數傳入newInstance(…)

5).通過代理對象調用目標方法

4、動態代理的使用

1).分步驟實現動態代理

public class MyProxy {public interface IHello{void sayHello();}static class Hello implements IHello{public void sayHello() {System.out.println("Hello world!!");}}//自定義InvocationHandlerstatic class HWInvocationHandler implements InvocationHandler{//目標對象private Object target;public HWInvocationHandler(Object target){this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("------插入前置通知代碼-------------");//執行相應的目標方法//利用反射機制將請求分派給實現類處理。Method的invoke返回Object對象作為方法執行結果//因為示例程序沒有返回值，所以這里忽略了返回值處理Object rs = method.invoke(target,args);System.out.println("------插入后置處理代碼-------------");return rs;}}public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc eption, InstantiationException {//設置生成$Proxy0的class文件保存到本地(sun.misc.ProxyGenerator是JDK代理生成器，在生成類是會根據參數“sun.misc.ProxyGenerator.saveGeneratedFiles”來決定是否將二進制文件保存到本地文件中)System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");//獲取動態代理類Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);//獲得代理類的構造函數，并傳入參數類型InvocationHandler.classConstructor constructor = proxyClazz.getConstructor(InvocationHandler.class);//通過構造函數來創建動態代理對象，將自定義的InvocationHandler實例傳入IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));//通過代理對象調用目標方法iHello.sayHello();} } 輸出： ------插入前置通知代碼------------- Hello world!! ------插入后置處理代碼-------------

2).簡化后的動態代理實現

Proxy類中還有個將2~4步驟封裝好的簡便方法來創建動態代理對象，其方法簽名為：

newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h) public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {//生成$Proxy0的class文件System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //加載接口的類加載器new Class[]{IHello.class}, //一組接口new HWInvocationHandler(new Hello())); //自定義的InvocationHandlerihello.sayHello(); }

以上就是JDK動態代理的使用。抱著知其然，也要知其所以然的態度，下面的內容我們就通過源碼來研究一下代理類是如何生成的(為了易看易懂省略部分次要代碼)。

首先我們以newProxyInstance方法為入口來看一下源碼是如何實現的:

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{if (h == null) { //如果h為空直接拋出異常，所以InvocationHandler實例對象是必須的throw new NullPointerException();}//對象的拷貝final Class<?>[] intfs = interfaces.clone();//一些安全的權限檢查final SecurityManager sm = System.getSecurityManager();if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);}//產生代理類Class<?> cl = getProxyClass0(loader, intfs);//獲取代理類的構造函數對象//參數constructorParames為常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };final Constructor<?> cons = cl.getConstructor(constructorParames);final InvocationHandler ih = h;//根據代理類的構造函數對象來創建代理類對象return newInstance(cons, ih); }

newInstance實現的是上面動態代理五大步驟中的第四步：通過Constructor.newInstance來構造相應的代理類實例。這段代碼的重點是生成代理類的方法getProxyClass0。

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { // 代理的接口數量不能超過65535if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // JDK對代理進行了緩存，如果已經存在相應的代理類，則直接返回，否則才會通過ProxyClassFactory來創建代理 return proxyClassCache.get(loader, interfaces); }

其中代理緩存是通過WeakCache實現的：

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

下面我們看看ProxyClassFactory是如何生辰代理類的，ProxyClassFactory是Proxy的一個靜態內部類，實現了WeakCache的內部接口BiFunction的apply方法：

private static final class ProxyClassFactoryimplements BiFunction<ClassLoader, Class<?>[], Class<?>>{//統一代理類的前綴名都以$Proxy開始private static final String proxyClassNamePrefix = "$Proxy";//用于生成代理類名字的計數器。使用唯一的編號給作為代理類名的一部分，如$Proxy0,$Proxy1等private static final AtomicLong nextUniqueNumber = new AtomicLong();@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {//**************驗證代理接口的代碼start******************************Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);for (Class<?> intf : interfaces) {//驗證指定的類加載器(loader)加載接口所得到的Class對象(interfaceClass)是否與intf對象相同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");}//驗證該Class對象是不是接口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());}}//**************驗證代理接口的代碼end******************************//聲明代理類所在包String proxyPkg = null; //對于非公共接口，代理類的包名與接口的相同/*驗證你傳入的接口中是否有非public接口，只要有一個接口是非public的，那么這些接口都必須在同一包中這里的接口修飾符直接影響到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成的代理類的路徑，往下看！！tf : 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");}}}//對于公共接口的包名，默認為com.sun.proxy if (proxyPkg == null) {/*如果都是public接口，那么生成的代理類就在com.sun.proxy包下如果報java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系統找不到指定的路徑。)的錯誤，就先在你項目中創建com.sun.proxy路徑*/ proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";}//獲取計數，將當前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理類的名字為$Proxy0.classlong num = nextUniqueNumber.getAndIncrement();//默認情況下，代理類的完全限定名為：com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1……依次遞增 String proxyName = proxyPkg + proxyClassNamePrefix + num;//這里才是生成代理類字節碼的地方 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);try {//根據二進制字節碼返回響應的class實例return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);} catch (ClassFormatError e) {throw new IllegalArgumentException(e.toString());}} }

ProxyGenerator是sun.misc包中的類，它沒有開源，但是可以反編譯來看看：

public static byte[] generateProxyClass(final String var0, Class[] var1) { ProxyGenerator var2 = new ProxyGenerator(var0, var1); //生成代理類字節碼文件的真正方法final byte[] var3 = var2.generateClassFile(); //保存文件，這里根據參數配置，決定是否把生成的字節碼（.class文件）保存到本地磁盤，我們可以通過把相應的class文件保存到本地，再反編譯來看看具體的實現，這樣更直觀 if(saveGeneratedFiles) { AccessController.doPrivileged(new PrivilegedAction() { public Void run() { try { FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class"); var1.write(var3); var1.close(); return null; } catch (IOException var2) { throw new InternalError("I/O exception saving generated file: " + var2); } } }); } return var3; }

注意saveGeneratedFiles這個屬性的值：

private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

GetBooleanAction實際上是調用Boolean.getBoolean(propName)來獲得的，而Boolean.getBoolean(propName)調用了System.getProperty(name)，所以我們可以設置sun.misc.ProxyGenerator.saveGeneratedFiles這個系統屬性為true來把生成的class保存到本地文件來查看。sun.misc.ProxyGenerator.saveGeneratedFiles的值我們上面在測試方法中是手動設置的。

這里要注意，當把這個屬性設置為true時，生成的class文件及其所在的路徑都需要提前創建，否則會拋出FileNotFoundException異常。即我們要在運行當前main方法的路徑下創建com/sun/proxy目錄，并創建一個$Proxy0.class文件，才能夠正常運行并保存class文件內容。

層層調用后，最終generateClassFile才是真正生成代理類字節碼文件的方法：

private byte[] generateClassFile() {/addProxyMethod系列方法就是將接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),其中方法簽名作為key,proxyMethod作為value*//*hashCodeMethod方法位于靜態代碼塊中通過Object對象獲得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),相當于從Object中繼承過來了這三個方法equalsMethod,toStringMethod*/ this.addProxyMethod(hashCodeMethod, Object.class); -->this.addProxyMethod(equalsMethod, Object.class);this.addProxyMethod(toStringMethod, Object.class);int var1;int var3;//獲得所有接口中的所有方法，并將方法添加到代理方法中for(var1 = 0; var1 < this.interfaces.length; ++var1) {Method[] var2 = this.interfaces[var1].getMethods(); for(var3 = 0; var3 < var2.length; ++var3) {this.addProxyMethod(var2[var3], this.interfaces[var1]);}}Iterator var7 = this.proxyMethods.values().iterator();List var8;while(var7.hasNext()) {var8 = (List)var7.next();//驗證具有相同方法簽名的的方法的返回值類型是否一致，因為不可能有兩個方法名相同,參數相同，而返回值卻不同的方法checkReturnTypes(var8); };//接下來就是寫代理類文件的步驟了Iterator var11try {//生成代理類的構造函數this.methods.add(this.generateConstructor());var7 = this.proxyMethods.values().iterator();while(var7.hasNext()) {var8 = (List)var7.next();var11 = var8.iterator();while(var11.hasNext()) {ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();/將代理字段聲明為Method，10為ACC_PRIVATE和ACC_STATAIC的與運算，表示該字段的修飾符為private static所以代理類的字段都是private static Method XXX*/this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));//生成代理類的代理方法this.methods.add(var4.generateMethod());}}//為代理類生成靜態代碼塊，對一些字段進行初始化this.methods.add(this.generateStaticInitializer());} catch (IOException var6) {throw new InternalError("unexpected I/O Exception");}if(this.methods.size() > '\uffff') { //代理方法超過65535將拋出異常throw new IllegalArgumentException("method limit exceeded");} else if(this.fields.size() > '\uffff') { //代理類的字段超過65535將拋出異常throw new IllegalArgumentException("field limit exceeded");} else {//這里開始就是一些代理類文件的過程，此過程略過this.cp.getClass(dotToSlash(this.className));this.cp.getClass("java/lang/reflect/Proxy");for(var1 = 0; var1 < this.interfaces.length; ++var1) {this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));}this.cp.setReadOnly();ByteArrayOutputStream var9 = new ByteArrayOutputStream();DataOutputStream var10 = new DataOutputStream(var9);try {var10.writeInt(-889275714);var10.writeShort(0);var10.writeShort(49);this.cp.write(var10);var10.writeShort(49);var10.writeShort(this.cp.getClass(dotToSlash(this.className)));var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));var10.writeShort(this.interfaces.length);for(var3 = 0; var3 < this.interfaces.length; ++var3) {var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));}var10.writeShort(this.fields.size());var11 = this.fields.iterator();while(var11.hasNext()) {ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();var12.write(var10);}var10.writeShort(this.methods.size());var11 = this.methods.iterator();while(var11.hasNext()) {ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();var13.write(var10);}var10.writeShort(0);return var9.toByteArray();} catch (IOException var5) {throw new InternalError("unexpected I/O Exception");}} }

注意：開頭的三個addProxyMethod方法是只將Object的hashcode,equals,toString方法添加到代理方法容器中，代理類除此之外并沒有重寫其他Object的方法，所以除這三個方法外，代理類調用其他方法的行為與Object調用這些方法的行為一樣不通過Invoke。

我們來看看addProxyMethod方法的實現：

private void addProxyMethod(Method var1, Class var2) {String var3 = var1.getName(); //方法名Class[] var4 = var1.getParameterTypes(); //方法參數類型數組Class var5 = var1.getReturnType(); //返回值類型Class[] var6 = var1.getExceptionTypes(); //異常類型String var7 = var3 + getParameterDescriptors(var4); //方法簽名Object var8 = (List)this.proxyMethods.get(var7); //根據方法簽名卻獲得proxyMethods的Valueif(var8 != null) { //處理多個代理接口中重復的方法的情況Iterator var9 = ((List)var8).iterator();while(var9.hasNext()) {ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();if(var5 == var10.returnType) {/*歸約異常類型以至于讓重寫的方法拋出合適的異常類型，我認為這里可能是多個接口中有相同的方法，而這些相同的方法拋出的異常類 型又不同，所以對這些相同方法拋出的異常進行了歸約*/ArrayList var11 = new ArrayList();collectCompatibleTypes(var6, var10.exceptionTypes, var11);collectCompatibleTypes(var10.exceptionTypes, var6, var11);var10.exceptionTypes = new Class[var11.size()];//將ArrayList轉換為Class對象數組var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);return;}}} else {//如果var8為空，就創建一個數組，并以方法簽名為key,proxymethod對象數組為value添加到proxyMethodsvar8 = new ArrayList(3);this.proxyMethods.put(var7, var8);} ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null)); }

以下就是上面我們測試實例中MyProxy的代理類：

public final class $Proxy0 extends Proxy implements IHello { //繼承了Proxy類和實現IHello接口//變量，都是private static Method XXXprivate static Method m3; private static Method m1;private static Method m0;private static Method m2;//代理類的構造函數，其參數正是是InvocationHandler實例，Proxy.newInstance方法就是通過通過這個構造函數來創建代理實例的public $Proxy0(InvocationHandler var1) throws {super(var1);}//接口代理方法public final void sayHello() throws {try {super.h.invoke(this, m3, (Object[])null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);}}//以下Object中的三個方法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 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);}}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);}}//對變量進行一些初始化工作static {try {m3 = Class.forName("com.proxy.IHello").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]);m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());}} }

我們來總結一下：

5、動態生成的代理類有如下特性：

1).繼承了Proxy類，實現了代理的接口，由于java不能多繼承，這里已經繼承了Proxy類了，不能再繼承其他的類，所以JDK的動態代理不支持對實現類的代理，只支持接口的代理。

2).重寫了Object類的equals、hashCode、toString，它們都只是簡單的調用了InvocationHandler的invoke方法，即可以對其進行特殊的操作，也就是說JDK的動態代理除了代理實現接口的方法外，還可以代理上述三個方法,可能的原因有：一是因為這些方法為 public 且非 final 類型，能夠被代理類覆蓋；二是因為這些方法往往呈現出一個類的某種特征屬性，具有一定的區分度，所以為了保證代理類與委托類對外的一致性，這三個方法也應該被分派到委托類執行。當代理的一組接口有重復聲明的方法且該方法被調用時，代理類總是從排在最前面的接口中獲取方法對象并分派給調用處理器，而無論代理類實例是否正在以該接口（或繼承于該接口的某子接口）的形式被外部引用，因為在代理類內部無法區分其當前的被引用類型。

3).代理類實現代理接口的sayHello方法中，只是簡單的調用了InvocationHandler的invoke方法，我們可以在invoke方法中進行一些特殊操作，甚至不調用實現的方法，直接返回。

4）包：如果所代理的接口都是 public 的，那么它將被定義在頂層包（即包路徑為空），如果所代理的接口中有非 public 的接口（因為接口不能被定義為 protect 或 private，所以除 public 之外就是默認的 package 訪問級別），那么它將被定義在該接口所在包（假設代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理類所在的包就是 com.ibm.developerworks），這樣設計的目的是為了最大程度的保證動態代理類不會因為包管理的問題而無法被成功定義并訪問；

5）類修飾符：該代理類具有 final 和 public 修飾符，意味著它可以被所有的類訪問，但是不能被再度繼承；

6）類名：格式是“$ProxyN”，其中 N 是一個逐一遞增的阿拉伯數字，代表 Proxy 類第 N 次生成的動態代理類，值得注意的一點是，并不是每次調用 Proxy 的靜態方法創建動態代理類都會使得 N 值增加，原因是如果對同一組接口（包括接口排列的順序相同）試圖重復創建動態代理類，它會很聰明地返回先前已經創建好的代理類的類對象，而不會再嘗試去創建一個全新的代理類，這樣可以節省不必要的代碼重復生成，提高了代理類的創建效率。

6、代理實例的特點：

每個實例都會關聯一個調用處理器對象，可以通過 Proxy 提供的靜態方法 getInvocationHandler 去獲得代理類實例的調用處理器對象。在代理類實例上調用其代理的接口中所聲明的方法時，這些方法最終都會由調用處理器的 invoke 方法執行.

7、被代理的接口的特點：

首先，要注意不能有重復的接口，以避免動態代理類代碼生成時的編譯錯誤。其次，這些接口對于類裝載器必須可見，否則類裝載器將無法鏈接它們，將會導致類定義失敗。再次，需被代理的所有非 public 的接口必須在同一個包中，否則代理類生成也會失敗。最后，接口的數目不能超過 65535，這是 JVM 設定的限制。

8、動態代理的異常處理：

從調用處理器接口聲明的方法中可以看到理論上它能夠拋出任何類型的異常，因為所有的異常都繼承于 Throwable 接口，但事實是否如此呢？答案是否定的，原因是我們必須遵守一個繼承原則：即子類覆蓋父類或實現父接口的方法時，拋出的異常必須在原方法支持的異常列表之內。所以雖然調用處理器理論上講能夠，但實際上往往受限制，除非父接口中的方法支持拋 Throwable 異常。那么如果在 invoke 方法中的確產生了接口方法聲明中不支持的異常，那將如何呢？放心，Java 動態代理類已經為我們設計好了解決方法：它將會拋出 UndeclaredThrowableException 異常。這個異常是一個 RuntimeException 類型，所以不會引起編譯錯誤。通過該異常的 getCause 方法，還可以獲得原來那個不受支持的異常對象，以便于錯誤診斷。

9、引申:

開頭說的spring AOP對于接口的來說就是通過JDK的動態代理來實現的，我們可以推測書spring AOP使用JDK動態代理實現的代碼如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // BeforeAdvice Object retVal = null; try { // AroundAdvice retVal = method.invoke(target, args); // AroundAdvice // AfterReturningAdvice } catch (Throwable e) { // AfterThrowingAdvice } finally { // AfterAdvice } return retVal; }

以上是博主結合日常的學習，從源碼的角度剖析了JDK動態代理的實現，之前在對別的博文進行學習的時候發現一篇文章，側重于從JVM的角度來講解動態代理實現，講的深入透徹，值得一看，鏈接如下：Java動態代理機制詳解（JDK 和CGLIB，Javassist，ASM）

總結

以上是生活随笔為你收集整理的【动态代理】从源码实现角度剖析JDK动态代理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。