java動態(tài)代理分析

　　定義：為其他對象提供一種代理以控制對這個對象的訪問。

　　動態(tài)代理使用

　　java動態(tài)代理機制以巧妙的方式實現(xiàn)了代理模式的設計理念。

　　代理模式示例代碼

　　publicinterfaceSubject{publicvoiddoSomething（）; }publicclassRealSubjectimplementsSubject{publicvoiddoSomething（） { System.out.println（“call doSomething（）”）; } }publicclassProxyHandlerimplementsInvocationHandler{privateObject proxied;publicProxyHandler（ Object proxied ） { this.proxied = proxied; } publicObject invoke（ Object proxy， Method method， Object［］ args ） throwsThrowable { //在轉調具體目標對象之前，可以執(zhí)行一些功能處理//轉調具體目標對象的方法returnmethod.invoke（ proxied， args）;//在轉調具體目標對象之后，可以執(zhí)行一些功能處理} }importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Method;importjava.lang.reflect.Proxy; importsun.misc.ProxyGenerator; importjava.io.*; /** * Java學習交流QQ群：589809992 我們一起學Java！ */publicclassDynamicProxy{publicstaticvoidmain（ String args［］ ） { RealSubject real =newRealSubject（）; Subject proxySubject = （Subject）Proxy.newProxyInstance（Subject.class.getClassLoader（）， newClass［］{Subject.class}， newProxyHandler（real））; proxySubject.doSomething（）; //write proxySubject class binary data to file createProxyClassFile（）; }publicstaticvoidcreateProxyClassFile（） { String name = “ProxySubject”; byte［］ data = ProxyGenerator.generateProxyClass（ name， newClass［］ { Subject.class } ）; try{ FileOutputStream out = newFileOutputStream（ name + “.class”）; out.write（ data ）; out.close（）; } catch（ Exception e ） { e.printStackTrace（）; } } }動態(tài)代理內部實現(xiàn)

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

　　// 映射表：用于維護類裝載器對象到其對應的代理類緩存privatestaticMap loaderToCache = newWeakHashMap（）; // 標記：用于標記一個動態(tài)代理類正在被創(chuàng)建中privatestaticObject pendingGenerationMarker = newObject（）; // 同步表：記錄已經被創(chuàng)建的動態(tài)代理類類型，主要被方法 isProxyClass 進行相關的判斷privatestaticMap proxyClasses = Collections.synchronizedMap（ newWeakHashMap（））; // 關聯(lián)的調用處理器引用protectedInvocationHandler h;

　　Proxy的構造方法

　　// 由于 Proxy 內部從不直接調用構造函數(shù)，所以 private 類型意味著禁止任何調用privateProxy（） {} // 由于 Proxy 內部從不直接調用構造函數(shù)，所以 protected 意味著只有子類可以調用protectedProxy（InvocationHandler h） { this.h = h;}

　　Proxy靜態(tài)方法newProxyInstance

　　// 檢查 h 不為空，否則拋異常if（h == null） { thrownewNullPointerException（）; } // 獲得與指定類裝載器和一組接口相關的代理類類型對象Class cl = getProxyClass（loader， interfaces）;// 通過反射獲取構造函數(shù)對象并生成代理類實例try{ Constructor cons = cl.getConstructor（constructorParams）; return（ Object） cons.newInstance（ newObject［］ { h }）; } catch（NoSuchMethodException e） { thrownewInternalError（e.toString（））; }catch（IllegalAccessException e） { thrownewInternalError（e.toString（））; }catch（InstantiationException e） { thrownewInternalError（e.toString（））; }catch（InvocationTargetException e） { thrownewInternalError（e.toString（））; } }

　　類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數(shù)據(jù)：

　　publicstaticbyte［］ generateProxyClass（ finalString name， Class［］ interfaces）

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

　　importjava.lang.reflect.*; /** * Java學習交流QQ群：589809992 我們一起學Java！ */publicfinalclassProxySubjectextendsProxyimplementsSubject{privatestaticMethod m1;privatestaticMethod m0; privatestaticMethod m3; privatestaticMethod m2;publicProxySubject（InvocationHandler invocationhandler） { super（invocationhandler）; }publicfinalbooleanequals（Object obj） { try{ return（（Boolean） super.h.invoke（ this， m1，newObject［］ { obj }））.booleanValue（）; } catch（Error _ex） { } catch（Throwable throwable） {thrownewUndeclaredThrowableException（throwable）; } } publicfinalinthashCode（） { try{return（（Integer） super.h.invoke（ this， m0， null））.intValue（）; } catch（Error _ex） { }catch（Throwable throwable） { thrownewUndeclaredThrowableException（throwable）; } }publicfinalvoiddoSomething（） { try{ super.h.invoke（ this， m3， null）; return; } catch（Error _ex） { } catch（Throwable throwable） {thrownewUndeclaredThrowableException（throwable）; } } publicfinalString toString（） { try{return（String） super.h.invoke（ this， m2， null）; } catch（Error _ex） { } catch（Throwable throwable） { thrownewUndeclaredThrowableException（throwable）; } } static{ try{ m1 = Class.forName（ “java.lang.Object”）.getMethod（ “equals”， newClass［］ { Class.forName（“java.lang.Object”） }）; m0 = Class.forName（ “java.lang.Object”）.getMethod（ “hashCode”，newClass［ 0］）; m3 = Class.forName（ “Subject”）.getMethod（ “doSomething”， newClass［ 0］）; m2 = Class.forName（ “java.lang.Object”）.getMethod（ “toString”， newClass［ 0］）; }catch（NoSuchMethodException nosuchmethodexception） {thrownewNoSuchMethodError（nosuchmethodexception.getMessage（））; }catch（ClassNotFoundException classnotfoundexception） {thrownewNoClassDefFoundError（classnotfoundexception.getMessage（））; } } }

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

　　privatebyte［］ generateClassFile（） { /* * Record that proxy methods are needed forthe hashCode， equals， * andtoString methods ofjava.lang.Object. This is donebefore * the methods from the proxy interfaces so that the methods from * java.lang.Object take precedence over duplicate methods inthe * proxy interfaces. */ addProxyMethod（hashCodeMethod， Object. class）; addProxyMethod（equalsMethod， Object. class）; addProxyMethod（toStringMethod， Object. class）; /* * Now record all ofthe methods from the proxy interfaces， giving * earlier interfaces precedence over later oneswithduplicate * 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 ofproxy methods withthe same signature， * verify that the methods‘ returntypes are compatible. */for（List《ProxyMethod》 sigmethods ： proxyMethods.values（）） { checkReturnTypes（sigmethods）; } /* ============================================================ * Step 2： Assemble FieldInfo andMethodInfo structs forall of* fields andmethods inthe classwe 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（ newFieldInfo（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 newInternalError（“unexpected I/O Exception”）; } /* ============================================================ * Step 3： Write the final classfile. */ /* * Make sure that constant pool indexes are reserved forthe * following items before starting towrite the final classfile. */ cp.getClass（dotToSlash（className））; cp.getClass（superclassName）; for（int i = 0; i 《 interfaces.length; i++） { cp.getClass（dotToSlash（interfaces［i］.getName（）））; } /* * Disallownewconstant pool additions beyond this point， since * we are about towrite the final constant pool table. */ cp.setReadOnly（）; ByteArrayOutputStream bout =newByteArrayOutputStream（）; DataOutputStream dout = newDataOutputStream（bout）;try{ /* * Write all the items ofthe “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 newInternalError（ “unexpected I/O Exception”）; } returnbout.toByteArray（）;總結

　　一個典型的動態(tài)代理創(chuàng)建對象過程可分為以下四個步驟：

　　1、通過實現(xiàn)InvocationHandler接口創(chuàng)建自己的調用處理器 IvocationHandler handler = new InvocationHandlerImpl（…）;

　　2、通過為Proxy類指定ClassLoader對象和一組interface創(chuàng)建動態(tài)代理類

　　Class clazz = Proxy.getProxyClass（classLoader，new Class［］{…}）;

　　3、通過反射機制獲取動態(tài)代理類的構造函數(shù)，其參數(shù)類型是調用處理器接口類型

　　Constructor constructor = clazz.getConstructor（new Class［］{InvocationHandler.class}）;

　　4、通過構造函數(shù)創(chuàng)建代理類實例，此時需將調用處理器對象作為參數(shù)被傳入

　　Interface Proxy = （Interface）constructor.newInstance（new Object［］ （handler））;

　　為了簡化對象創(chuàng)建過程，Proxy類中的newInstance方法封裝了2~4，只需兩步即可完成代理對象的創(chuàng)建。

　　生成的ProxySubject繼承Proxy類實現(xiàn)Subject接口，實現(xiàn)的Subject的方法實際調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的的方法（Object result=method.invoke（proxied，args））

　　美中不足

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