JAVA动态代理的内部实现
2010-04-27 20:35
363 查看
[b][b]JAVA动态代理的内部实现 [/b][/b]
[b]一 代理设计模式 [/b]
代理模式为目标对象提供一种代理以控制对实际对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。为了保持行为的一致性,代理类和实际委托类通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。
代理模式类图
常见的代理有:
1) 远程代理(Remote Proxy):对一个位于不同的地址空间对象提供一个局域代表对象,如RMI中的stub。
2) 虚拟代理(Virtual Proxy):根据需要将一个资源消耗很大或者比较复杂的对象,延迟加载,在真正需要的时候才创建。
3) 保护代理(Protect or Access Proxy):控制对一个对象的访问权限。
4) 智能引用(Smart Reference Proxy):提供比目标对象额外的服务和功能。
通过代理类这一中间层,能够有效控制对实际委托类对象的直接访问,也可以很好地隐藏和保护实际对象,实施不同的控制策略,从而在设计上获得了更大的灵活性。
二 动态代理使用
JAVA动态代理机制以巧妙的方式实现了代理模式的设计理念。动态代理类图
动态代理在代理ProxySubject和RealSubject之间增加了InvocationHandler这一层,这是一种通信间接化,增加了灵 性性,例如可以把这个中间层实现为一个框架Framework,直接通过xml文件等方式来调用RealSubject。
在普通的设计中,我们一般不会使用动态代理。但是在一些框架结构设计中,动态代理非常重要,如RMI,EJB中都使用动态代理。
动态代理具体使用如下:
interface Subject { public void doSomething(); } class RealSubject implements Subject { public void doSomething() { System.out.println( "call doSomething()" ); } } class ProxyHandler implements InvocationHandler { private Object proxied; public ProxyHandler( Object proxied ) { this.proxied = proxied; } public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable { return method.invoke( proxied, args); } }
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import sun.misc.ProxyGenerator; import java.io.*; public class DynamicProxy { public static void main( String args[] ) { RealSubject real = new RealSubject(); Subject proxySubject = ( Subject ) Proxy.newProxyInstance( Subject.class.getClassLoader(), new Class[] { Subject.class }, new ProxyHandler( real ) ); proxySubject.doSomething(); //write proxySubject class binary data to file createProxyClassFile(); } public static void createProxyClassFile() { String name = "ProxySubject"; byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } ); try { FileOutputStream out = new FileOutputStream( name + ".class" ); out.write( data ); out.close(); } catch( Exception e ) { e.printStackTrace(); } } }
三 动态代理内部实现
通过调用Proxy类的newProxyInstance工厂方法,动态地生成了ProxySubject,所有的方法调用都被委派到InvocationHandler的invoke方法,invoke方法通关Method反射执行RealSubject对应的方法.我们可以推测动态代理类ProxySubject肯定实现了Subjedt接口,并包含一个InvocationHandler对象引用,这是从Proxy继承而得到的。当调用接口中的每个方法时。通过反射调用得到对应的Method对象。并调用invoke方法。我们可以验证我们的推测是否时正确的。通过Proxy类的源代码我们了解类Proxy的getProxyClass方法调用ProxyGenerator的 generateProxyClass方法产生ProxySubject.class的二进制数据:
public static byte[] generateProxyClass(final String name, Class[] interfaces)
我们可以import sun.misc.ProxyGenerator,调用 generateProxyClass方法产生binary data,然后写入文件,最后通过反编译工具来查看内部实现原理,如上面的createProxyClassFile()方法。
反编译后的ProxySubject.java如下,其中无关的代码被删除了。
import java.lang.reflect.*; public final class ProxySubject extends Proxy implements Subject { private static Method doSomething; public ProxySubject(InvocationHandler invocationhandler) { super(invocationhandler); } public final void doSomething() { try { super.invocationhandler.invoke(this, doSomething, null); return; } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } static { try { doSomething = Class.forName("Subject").getMethod("doSomething", new Class[0]); } catch(NoSuchMethodException nosuchmethodexception) { throw new NoSuchMethodError(nosuchmethodexception.getMessage()); } catch(ClassNotFoundException classnotfoundexception) { throw new NoClassDefFoundError(classnotfoundexception.getMessage()); } } }
我们可以看到动态代理的内部实现和我们前面的推测相同,并且我们可以实现自己的一个动态代理生成器。如果你想探究ProxyGenerator内部是如何生成class二进制数据,可以参考下面部分的源代码。
private byte[] generateClassFile() { /* * Step 1: 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();
相关文章推荐
- 转:Java 动态代理的内部实现机制(大体意思正确,写的还行的一篇文章)
- JAVA动态代理内部实现
- JAVA动态代理内部实现
- java动态代理的内部实现
- JAVA动态代理内部实现
- 代理模式之Java动态代理实现方法
- 设计模式-java实现动态代理
- 【Java进阶-Java动态代理与AOP】04 实现InvocationHandler的invoke方法
- java使用动态代理来实现AOP(日志记录)的实例代码
- Proxy实现java动态代理
- Java动态代理的实现
- JAVA动态绑定的内部实现机制
- Java动态代理实现
- Java动态代理实现
- JAVA动态代理 和 Spring AOP 4种通知的简单实现
- 用Java动态代理实现AOP
- 动态代理使用以及Proxy的内部实现
- java之动态代理简单实现
- Java动态代理的两种实现方法
- Java JDK 动态代理使用及实现原理分析