一、什么是動態(tài)代理

　　動態(tài)代理可以提供對另一個對象的訪問，同時隱藏實(shí)際對象的具體事實(shí)。代理一般會實(shí)現(xiàn)它所表示的實(shí)際對象的接口。代理可以訪問實(shí)際對象，但是延遲實(shí)現(xiàn)實(shí)際對象的部分功能，實(shí)際對象實(shí)現(xiàn)系統(tǒng)的實(shí)際功能，代理對象對客戶隱藏了實(shí)際對象。客戶不知道它是與代理打交道還是與實(shí)際對象打交道。

?

目的：主要用來做方法的增強(qiáng)，讓你可以在不修改源碼（不用改變這個方法的簽名，原來調(diào)用這個方法的類依然能正常工作）的情況下，增強(qiáng)一些方法。在方法執(zhí)行前后做任何你想做的事情（甚至根本不去執(zhí)行這個方法），因?yàn)樵贗nvocationHandler的invoke方法中，你可以直接獲取正在調(diào)用方法對應(yīng)的Method對象，具體應(yīng)用的話，比如可以添加調(diào)用日志，做事務(wù)控制等。

還有一個有趣的作用是可以用作遠(yuǎn)程調(diào)用，比如現(xiàn)在有Java接口，這個接口的實(shí)現(xiàn)部署在其它服務(wù)器上，在編寫客戶端代碼的時候，沒辦法直接調(diào)用接口方法，因?yàn)榻涌谑遣荒苤苯由蓪ο蟮?#xff0c;這個時候就可以考慮代理模式（動態(tài)代理）了，通過Proxy.newProxyInstance代理一個該接口對應(yīng)的InvocationHandler對象，然后在InvocationHandler的invoke方法內(nèi)封裝通訊細(xì)節(jié)就可以了。具體的應(yīng)用，最經(jīng)典的當(dāng)然是Java標(biāo)準(zhǔn)庫的RMI，其它比如hessian，各種webservice框架中的遠(yuǎn)程調(diào)用，大致都是這么實(shí)現(xiàn)的。
而像?AspectJ?這種?AOP?剛不同，它直接把人家的?class?代碼修改了，它就不需要使用代理。
這些在新的?JDK?6?中都可以通過?Instrument?來做到，不過也是個通用的方法，還得通過規(guī)則來定制什么情況下處理，什么時候不處理。

?

二、jdk的動態(tài)代理

　　目前Java開發(fā)包中包含了對動態(tài)代理的支持，但是其實(shí)現(xiàn)只支持對接口的的實(shí)現(xiàn)。 其實(shí)現(xiàn)主要通過java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。?

　　Proxy類主要用來獲取動態(tài)代理對象，InvocationHandler接口用來約束調(diào)用者實(shí)現(xiàn)。

　　動態(tài)代理是很多框架和技術(shù)的基礎(chǔ), spring 的AOP實(shí)現(xiàn)就是基于動態(tài)代理實(shí)現(xiàn)的。了解動態(tài)代理的機(jī)制對于理解AOP的底層實(shí)現(xiàn)是很有幫助的。

?

2.1、Proxy類

Porxy類也是在java.lang.reflect，Proxy 提供用于創(chuàng)建動態(tài)代理類和實(shí)例的靜態(tài)方法，它還是由這些方法創(chuàng)建的所有動態(tài)代理類的超類。?

代理類具用以下屬性：

• 代理類是公共的、最終的，而不是抽象的。
• 未指定代理類的非限定名稱。但是，以字符串 "$Proxy" 開頭的類名空間應(yīng)該為代理類保留。
• 代理類擴(kuò)展 java.lang.reflect.Proxy。
• 代理類會按同一順序準(zhǔn)確地實(shí)現(xiàn)其創(chuàng)建時指定的接口。
• 如果代理類實(shí)現(xiàn)了非公共接口，那么它將在與該接口相同的包中定義。否則，代理類的包也是未指定的。注意，包密封將不阻止代理類在運(yùn)行時在特定包中的成功定義，也不會阻止相同類加載器和帶有特定簽名的包所定義的類。
• 由于代理類將實(shí)現(xiàn)所有在其創(chuàng)建時指定的接口，所以對其 Class 對象調(diào)用 getInterfaces 將返回一個包含相同接口列表的數(shù)組（按其創(chuàng)建時指定的順序），對其 Class 對象調(diào)用 getMethods 將返回一個包括這些接口中所有方法的 Method 對象的數(shù)組，并且調(diào)用 getMethod 將會在代理接口中找到期望的一些方法。
• 如果 Proxy.isProxyClass 方法傳遞代理類（由 Proxy.getProxyClass 返回的類，或由 Proxy.newProxyInstance 返回的對象的類），則該方法返回 true，否則返回 false。
• 代理類的 java.security.ProtectionDomain 與由引導(dǎo)類加載器（如 java.lang.Object）加載的系統(tǒng)類相同，原因是代理類的代碼由受信任的系統(tǒng)代碼生成。此保護(hù)域通常被授予 java.security.AllPermission。
• 每個代理類都有一個可以帶一個參數(shù)（接口 InvocationHandler 的實(shí)現(xiàn)）的公共構(gòu)造方法，用于設(shè)置代理實(shí)例的調(diào)用處理程序。并非必須使用反射 API 才能訪問公共構(gòu)造方法，通過調(diào)用 Proxy.newInstance 方法（將調(diào)用 Proxy.getProxyClass 的操作和調(diào)用帶有調(diào)用處理程序的構(gòu)造方法結(jié)合在一起）也可以創(chuàng)建代理實(shí)例。?

方法

protected Proxy(InvocationHandler h) //使用其調(diào)用處理程序的指定值從子類（通常為動態(tài)代理類）構(gòu)建新的 Proxy 實(shí)例。

static InvocationHandler getInvocationHandler(Object proxy) //返回指定代理實(shí)例的調(diào)用處理程序。

static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) //返回代理類的 java.lang.Class 對象，并向其提供類加載器和接口數(shù)組。

static boolean isProxyClass(Class<?> cl) //當(dāng)且僅當(dāng)指定的類通過 getProxyClass 方法或 newProxyInstance 方法動態(tài)生成為代理類時，返回 true。

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) //返回一個指定接口的代理類實(shí)例，該接口可以將方法調(diào)用指派到指定的調(diào)用處理程序。

2.1、InvocationHandler接口

InvocationHandler接口也是在java.lang.reflect，唯一的一個方法是invoke如下：

Object invoke(Object proxy, Method method, Object[] args)

?這個方法有三個參數(shù)，其中第二和第三個參數(shù)都比較好理解，一個是被攔截的方法，一個是該方法的參數(shù)列表。關(guān)鍵是第一個參數(shù)。按照doc文檔的解析，proxy?- the proxy instance that the method was invoked on也就是說，proxy應(yīng)該是一個代理實(shí)例（動態(tài)代理類）。

?

三、示例

好了，在介紹完這兩個接口(類)以后，我們來通過一個實(shí)例來看看我們的動態(tài)代理模式是什么樣的：

首先我們定義了一個Subject類型的接口，為其聲明了兩個方法：

public interface Subject {public void rent();public void hello(String str); }

接著，定義了一個類來實(shí)現(xiàn)這個接口，這個類就是我們的真實(shí)對象，RealSubject類：

public class RealSubject implements Subject {@Overridepublic void rent(){System.out.println("I want to rent my house");}@Overridepublic void hello(String str){System.out.println("hello: " + str);} }

下一步，我們就要定義一個動態(tài)代理類了，前面說個，每一個動態(tài)代理類都必須要實(shí)現(xiàn) InvocationHandler 這個接口，因此我們這個動態(tài)代理類也不例外：

public class DynamicProxy implements InvocationHandler {//　這個就是我們要代理的真實(shí)對象private Object subject;// 構(gòu)造方法，給我們要代理的真實(shí)對象賦初值public DynamicProxy(Object subject){this.subject = subject;}@Overridepublic Object invoke(Object object, Method method, Object[] args)throws Throwable{//　　在代理真實(shí)對象前我們可以添加一些自己的操作System.out.println("before rent house");System.out.println("Method:" + method);// 當(dāng)代理對象調(diào)用真實(shí)對象的方法時，其會自動的跳轉(zhuǎn)到代理對象關(guān)聯(lián)的handler對象的invoke方法來進(jìn)行調(diào)用method.invoke(subject, args);//　　在代理真實(shí)對象后我們也可以添加一些自己的操作System.out.println("after rent house");return null;}}

最后，來看看我們的Client類：

public class Client {public static void main(String[] args){// 我們要代理的真實(shí)對象Subject realSubject = new RealSubject();// 我們要代理哪個真實(shí)對象，就將該對象傳進(jìn)去，最后是通過該真實(shí)對象來調(diào)用其方法的InvocationHandler handler = new DynamicProxy(realSubject);/** 通過Proxy的newProxyInstance方法來創(chuàng)建我們的代理對象，我們來看看其三個參數(shù)* 第一個參數(shù) handler.getClass().getClassLoader() ，我們這里使用handler這個類的ClassLoader對象來加載我們的代理對象* 第二個參數(shù)realSubject.getClass().getInterfaces()，我們這里為代理對象提供的接口是真實(shí)對象所實(shí)行的接口，表示我要代理的是該真實(shí)對象，這樣我就能調(diào)用這組接口中的方法了* 第三個參數(shù)handler， 我們這里將這個代理對象關(guān)聯(lián)到了上方的 InvocationHandler 這個對象上*/Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);System.out.println(subject.getClass().getName());subject.rent();subject.hello("world");} }

我們先來看看控制臺的輸出：

$Proxy0
before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent() I want to rent my house after rent house
before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String) hello: world after rent house

我們首先來看看?$Proxy0 這東西，我們看到，這個東西是由?System.out.println(subject.getClass().getName()); 這條語句打印出來的，那么為什么我們返回的這個代理對象的類名是這樣的呢？

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);

可能我以為返回的這個代理對象會是Subject類型的對象，或者是InvocationHandler的對象，結(jié)果卻不是，首先我們解釋一下為什么我們這里可以將其轉(zhuǎn)化為Subject類型的對象？原因就是在newProxyInstance這個方法的第二個參數(shù)上，我們給這個代理對象提供了一組什么接口，那么我這個代理對象就會實(shí)現(xiàn)了這組接口，這個時候我們當(dāng)然可以將這個代理對象強(qiáng)制類型轉(zhuǎn)化為這組接口中的任意一個，因?yàn)檫@里的接口是Subject類型，所以就可以將其轉(zhuǎn)化為Subject類型了。

同時我們一定要記住，通過?Proxy.newProxyInstance 創(chuàng)建的代理對象是在jvm運(yùn)行時動態(tài)生成的一個對象，它并不是我們的InvocationHandler類型，也不是我們定義的那組接口的類型，而是在運(yùn)行是動態(tài)生成的一個對象，并且命名方式都是這樣的形式，以$開頭，proxy為中，最后一個數(shù)字表示對象的標(biāo)號。

接著我們來看看這兩句?

subject.rent();
subject.hello("world");

這里是通過代理對象來調(diào)用實(shí)現(xiàn)的那種接口中的方法，這個時候程序就會跳轉(zhuǎn)到由這個代理對象關(guān)聯(lián)到的 handler 中的invoke方法去執(zhí)行，而我們的這個 handler 對象又接受了一個 RealSubject類型的參數(shù)，表示我要代理的就是這個真實(shí)對象，所以此時就會調(diào)用 handler 中的invoke方法去執(zhí)行：

public Object invoke(Object object, Method method, Object[] args)throws Throwable{//　　在代理真實(shí)對象前我們可以添加一些自己的操作System.out.println("before rent house");System.out.println("Method:" + method);// 當(dāng)代理對象調(diào)用真實(shí)對象的方法時，其會自動的跳轉(zhuǎn)到代理對象關(guān)聯(lián)的handler對象的invoke方法來進(jìn)行調(diào)用method.invoke(subject, args);//　　在代理真實(shí)對象后我們也可以添加一些自己的操作System.out.println("after rent house");return null;}

我們看到，在真正通過代理對象來調(diào)用真實(shí)對象的方法的時候，我們可以在該方法前后添加自己的一些操作，同時我們看到我們的這個 method 對象是這樣的：

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

正好就是我們的Subject接口中的兩個方法，這也就證明了當(dāng)我通過代理對象來調(diào)用方法的時候，起實(shí)際就是委托由其關(guān)聯(lián)到的 handler 對象的invoke方法中來調(diào)用，并不是自己來真實(shí)調(diào)用，而是通過代理的方式來調(diào)用的。

動態(tài)代理內(nèi)部實(shí)現(xiàn)

首先來看看類Proxy的代碼實(shí)現(xiàn)?Proxy的主要靜態(tài)變量

// 映射表：用于維護(hù)類裝載器對象到其對應(yīng)的代理類緩存 private static Map loaderToCache = new WeakHashMap(); // 標(biāo)記：用于標(biāo)記一個動態(tài)代理類正在被創(chuàng)建中 private static Object pendingGenerationMarker = new Object(); // 同步表：記錄已經(jīng)被創(chuàng)建的動態(tài)代理類類型，主要被方法 isProxyClass 進(jìn)行相關(guān)的判斷 private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); // 關(guān)聯(lián)的調(diào)用處理器引用 protected InvocationHandler h;

Proxy的構(gòu)造方法

// 由于 Proxy 內(nèi)部從不直接調(diào)用構(gòu)造函數(shù)，所以 private 類型意味著禁止任何調(diào)用 private Proxy() {} // 由于 Proxy 內(nèi)部從不直接調(diào)用構(gòu)造函數(shù)，所以 protected 意味著只有子類可以調(diào)用 protected Proxy(InvocationHandler h) {this.h = h;}

Proxy靜態(tài)方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException { // 檢查 h 不為空，否則拋異常if (h == null) { throw new NullPointerException(); } // 獲得與指定類裝載器和一組接口相關(guān)的代理類類型對象Class cl = getProxyClass(loader, interfaces); // 通過反射獲取構(gòu)造函數(shù)對象并生成代理類實(shí)例try { Constructor cons = cl.getConstructor(constructorParams); return (Object) cons.newInstance(new Object[] { h }); } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } catch (IllegalAccessException e) { throw new InternalError(e.toString()); } catch (InstantiationException e) { throw new InternalError(e.toString()); } catch (InvocationTargetException e) { throw new InternalError(e.toString()); } }

類Proxy的getProxyClass方法調(diào)用ProxyGenerator的?generateProxyClass方法產(chǎn)生ProxySubject.class的二進(jìn)制數(shù)據(jù)：

public static byte[] generateProxyClass(final String name, Class[] interfaces)

我們可以import sun.misc.ProxyGenerator，調(diào)用?generateProxyClass方法產(chǎn)生binary data，然后寫入文件，最后通過反編譯工具來查看內(nèi)部實(shí)現(xiàn)原理。 反編譯后的ProxySubject.java?Proxy靜態(tài)方法newProxyInstance

import java.lang.reflect.*; public final class ProxySubject extends Proxy implements Subject { private static Method m1; private static Method m0; private static Method m3; private static Method m2; public ProxySubject(InvocationHandler invocationhandler) { super(invocationhandler); } public final boolean equals(Object obj) { try { return ((Boolean)super.h.invoke(this, m1, new Object[] { obj })).booleanValue(); } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } public final int hashCode() { try { return ((Integer)super.h.invoke(this, m0, null)).intValue(); } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } public final void doSomething() { try { super.h.invoke(this, m3, null); return; } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } public final String toString() { try { return (String)super.h.invoke(this, m2, null); } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } static { try { 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]); m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); } catch(NoSuchMethodException nosuchmethodexception) { throw new NoSuchMethodError(nosuchmethodexception.getMessage()); } catch(ClassNotFoundException classnotfoundexception) { throw new NoClassDefFoundError(classnotfoundexception.getMessage()); } } }

ProxyGenerator內(nèi)部是如何生成class二進(jìn)制數(shù)據(jù)，可以參考源代碼。

private byte[] generateClassFile() { /* * Record that proxy methods are needed for the hashCode, equals, * and toString methods of java.lang.Object. This is done before * the methods from the proxy interfaces so that the methods from * java.lang.Object take precedence over duplicate methods in the * proxy interfaces. */ addProxyMethod(hashCodeMethod, Object.class); addProxyMethod(equalsMethod, Object.class); addProxyMethod(toStringMethod, Object.class); /* * Now record all of the methods from the proxy interfaces, giving * earlier interfaces precedence over later ones with duplicate * methods. */ 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. */ try { methods.add(generateConstructor()); for (List<ProxyMethod> sigmethods : proxyMethods.values()) { for (ProxyMethod pm : sigmethods) { // add static field for method's Method object fields.add(new FieldInfo(pm.methodFieldName, "Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC)); // generate code for proxy method and add it methods.add(pm.generateMethod()); } } methods.add(generateStaticInitializer()); } catch (IOException e) { throw new InternalError("unexpected I/O Exception"); } /* ============================================================ * Step 3: Write the final class file. */ /* * Make sure that constant pool indexes are reserved for the * following items before starting to write the final class file. */ cp.getClass(dotToSlash(className)); cp.getClass(superclassName); for (int i = 0; i < interfaces.length; i++) { cp.getClass(dotToSlash(interfaces[i].getName())); } /* * Disallow new constant pool additions beyond this point, since * we are about to write the final constant pool table. */ cp.setReadOnly(); ByteArrayOutputStream bout = new ByteArrayOutputStream(); DataOutputStream dout = new DataOutputStream(bout); try { /* * Write all the items of the "ClassFile" structure. * See JVMS section 4.1. */ // 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();

總結(jié)

一個典型的動態(tài)代理創(chuàng)建對象過程可分為以下四個步驟：
1、通過實(shí)現(xiàn)InvocationHandler接口創(chuàng)建自己的調(diào)用處理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2、通過為Proxy類指定ClassLoader對象和一組interface創(chuàng)建動態(tài)代理類
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3、通過反射機(jī)制獲取動態(tài)代理類的構(gòu)造函數(shù)，其參數(shù)類型是調(diào)用處理器接口類型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通過構(gòu)造函數(shù)創(chuàng)建代理類實(shí)例，此時需將調(diào)用處理器對象作為參數(shù)被傳入
Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
為了簡化對象創(chuàng)建過程，Proxy類中的newInstance方法封裝了2~4，只需兩步即可完成代理對象的創(chuàng)建。
生成的ProxySubject繼承Proxy類實(shí)現(xiàn)Subject接口，實(shí)現(xiàn)的Subject的方法實(shí)際調(diào)用處理器的invoke方法，而invoke方法利用反射調(diào)用的是被代理對象的的方法（Object result=method.invoke(proxied,args)）

美中不足

誠然，Proxy已經(jīng)設(shè)計(jì)得非常優(yōu)美，但是還是有一點(diǎn)點(diǎn)小小的遺憾之處，那就是它始終無法擺脫僅支持interface代理的桎梏，因?yàn)樗脑O(shè)計(jì)注定了這個遺憾。回想一下那些動態(tài)生成的代理類的繼承關(guān)系圖，它們已經(jīng)注定有一個共同的父類叫Proxy。Java的繼承機(jī)制注定了這些動態(tài)代理類們無法實(shí)現(xiàn)對class的動態(tài)代理，原因是多繼承在Java中本質(zhì)上就行不通。有很多條理由，人們可以否定對 class代理的必要性，但是同樣有一些理由，相信支持class動態(tài)代理會更美好。接口和類的劃分，本就不是很明顯，只是到了Java中才變得如此的細(xì)化。如果只從方法的聲明及是否被定義來考量，有一種兩者的混合體，它的名字叫抽象類。實(shí)現(xiàn)對抽象類的動態(tài)代理，相信也有其內(nèi)在的價值。此外，還有一些歷史遺留的類，它們將因?yàn)闆]有實(shí)現(xiàn)任何接口而從此與動態(tài)代理永世無緣。如此種種，不得不說是一個小小的遺憾。但是，不完美并不等于不偉大，偉大是一種本質(zhì)，Java動態(tài)代理就是佐例。

cglib

jdk給目標(biāo)類提供動態(tài)要求目標(biāo)類必須實(shí)現(xiàn)接口，當(dāng)一個目標(biāo)類不實(shí)現(xiàn)接口時，jdk是無法為其提供動態(tài)代理的。cglib 卻能給這樣的類提供動態(tài)代理。

詳細(xì)見：Java之代理（jdk靜態(tài)代理，jdk動態(tài)代理，cglib動態(tài)代理，aop，aspectj）

Spring AOP

詳細(xì)見：Spring AOP 實(shí)現(xiàn)原理

攔截器

struts2攔截器的實(shí)現(xiàn)原理及源碼剖析

轉(zhuǎn)載于:https://www.cnblogs.com/duanxz/archive/2012/12/03/2799504.html

與50位技術(shù)專家面對面20年技術(shù)見證，附贈技術(shù)全景圖

總結(jié)

以上是生活随笔為你收集整理的JDK的动态代理深入解析（Proxy,InvocationHandler）（转）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。