java动态代理分析

　　定义：为其他对象提供一种代理以控制对这个对象的访问。

　　动态代理使用

　　java动态代理机制以巧妙的方式实现了代理模式的设计理念。

　　代理模式示例代码

　　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 { //在转调具体目标对象之前，可以执行一些功能处理//转调具体目标对象的方法returnmethod.invoke（ proxied， args）;//在转调具体目标对象之后，可以执行一些功能处理} }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（）; } } }动态代理内部实现

　　首先来看看类Proxy的代码实现 Proxy的主要静态变量

　　// 映射表：用于维护类装载器对象到其对应的代理类缓存privatestaticMap loaderToCache = newWeakHashMap（）; // 标记：用于标记一个动态代理类正在被创建中privatestaticObject pendingGenerationMarker = newObject（）; // 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断privatestaticMap proxyClasses = Collections.synchronizedMap（ newWeakHashMap（））; // 关联的调用处理器引用protectedInvocationHandler h;

　　Proxy的构造方法

　　// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用privateProxy（） {} // 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用protectedProxy（InvocationHandler h） { this.h = h;}

　　Proxy静态方法newProxyInstance

　　// 检查 h 不为空，否则抛异常if（h == null） { thrownewNullPointerException（）; } // 获得与指定类装载器和一组接口相关的代理类类型对象Class cl = getProxyClass（loader， interfaces）;// 通过反射获取构造函数对象并生成代理类实例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的二进制数据：

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

　　我们可以import sun.misc.ProxyGenerator，调用 generateProxyClass方法产生binary data，然后写入文件，最后通过反编译工具来查看内部实现原理。 反编译后的ProxySubject.java Proxy静态方法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二进制数据，可以参考源代码。

　　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（）;总结

　　一个典型的动态代理创建对象过程可分为以下四个步骤：

　　1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl（…）;

　　2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类

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

　　3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型

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

　　4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入

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

　　为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。

　　生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke（proxied，args））

　　美中不足

　　诚然，Proxy已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫Proxy。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理，原因是多继承在Java中本质上就行不通。有很多条理由，人们可以否定对 class代理的必要性，但是同样有一些理由，相信支持class动态代理会更美好。接口和类的划分，本就不是很明显，只是到了Java中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。但是，不完美并不等于不伟大，伟大是一种本质，Java动态代理就是佐例。