动态代理的东东 听起来很牛，用起别人提供的现成的工具，也很方便，比如spring 的事务管理，虽然我们用的是和不是很多，但是真正用的时候，会有一些意想不到的东东出现，本着知其然并知其所以然的原则，我们来看下到底是怎么实现的
下面会研究下 java本身实现的动态代理，cglib实现的动态代理， 其他的比如bcel和javassist实现的，大家可以自己研究下，大同小异
好了，我们开始，本着诚实的原则(第二个原则) ，下面的内容错了的都是我的，对的都是自立的J。
首先看下两个实现是怎么写的，上代码(很烦，但是很必要)，由于java是需要接口的，因此我们会有一个接口，同时会有实现，模拟一个简单的计时的动态代理
接口：public interface IHello { public String sayHello(String ts);}
实现：public class HelloWorld implements IHello{ public String sayHello(String ts) { return "hello "+ts; }}
Java的实现
public class DynaHello implements InvocationHandler {
private Object obj;
public DynaHello(Object obj) { this.obj = obj;}
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
long start = System.currentTimeMillis();
Object o = method.invoke(obj, args);
System.out.println("Call to sayHello took "+ (System.currentTimeMillis() - start) + " ms.");
return o;
}
}
Cglib的实现
public class cglibProxy implements MethodInterceptor {
private Enhancer enhancer=new Enhancer();
public Object getProxyInstance(Class clz){
enhancer.setSuperclass(clz);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
long start = System.currentTimeMillis();
Object o = proxy.invokeSuper(obj, args);
System.out.println("Call to sayHello took " + (System.currentTimeMillis() - start) + " ms.");
return o;
}
}
测试java 动态代理类
public class TestJavaDyna {
public static void main(String[] args) {
HelloWorld hw = new HelloWorld();
DynaHello dh = new DynaHello(hw);
IHello hello = (IHello) Proxy.newProxyInstance(hw.getClass().getClassLoader(), hw.getClass().getInterfaces(), dh);
hello.sayHello("hello world");
}
}
下面我们来看下java是怎么实现动态代理的
首先来看Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
很简单，除去异常的处理，就三句话
Class cl = getProxyClass(loader, interfaces);//@1生成一个class
Constructor cons = cl.getConstructor(constructorParams);//@2得到这个class的构造函数
return (Object) cons.newInstance(new Object[] { h });//@3用这个构造函数，和构造函数的参数 构造一个对象 然后返回
其中constructorParams ={ InvocationHandler.class }; h就是传入的InvocationHandler的实现，这里面会在生成字节码的时候，设置进去自己的父类 java/lang/reflect/Proxy，父类有一个有参构造函数比较重要
protected Proxy(InvocationHandler h) { this.h = h; } 。
下面的这幅图也许比较清晰
从上面可以看到主要还是生成代理类字节码，详细的就不讲了，举个例子讲下怎么生成对应的代理方法的，下面的就是方法生成中用到的代码
//1、这几句字节码的意思得到父类的一个属性，类型为InvocationHandler，此时superclassName = "java/lang/reflect/Proxy",handlerFieldName = "h";
out.writeByte(opc_getfield); out.writeShort(cp.getFieldRef( superclassName, handlerFieldName, "Ljava/lang/reflect/InvocationHandler;"));
//2、这句话对应的字节码就是aload_0，也就是this的引用
code_aload(0, out);
//3、这几句是得到静态属性，类型为Method，className= proxyPkg + $Proxy + num, proxyPkg是包名，因为接口的类型可以是public或者默认，public的时候proxyPkg就是空，默认的话，就需要代理类和接口在一个包内，包可见。
// num是自增计数器，methodFieldName就是代理类中的属性的name
out.writeByte(opc_getstatic); out.writeShort(cp.getFieldRef(dotToSlash(className),methodFieldName, "Ljava/lang/reflect/Method;"));
//4、下面是对应方法中的参数，如果没有则是空null
if (parameterTypes.length > 0) { code_ipush(parameterTypes.length, out);out.writeByte(opc_anewarray); out.writeShort(cp.getClass("java/lang/Object"));
for (int i = 0; i < parameterTypes.length; i++) {
out.writeByte(opc_dup);
code_ipush(i, out);
codeWrapArgument(parameterTypes[i], parameterSlot[i], out);
out.writeByte(opc_aastore);
}
} else {
out.writeByte(opc_aconst_null);
}
//5、下面两句话是调用接口，第一个参数为上面load的this，第二个参数为对应Method类型的方法，第三个参数就是上面组装的方法中的参数
out.writeByte(opc_invokeinterface);
out.writeShort(cp.getInterfaceMethodRef("java/lang/reflect/InvocationHandler","invoke","(Ljava/lang/Object;Ljava/lang/reflect/Method;" +"[Ljava/lang/Object;)Ljava/lang/Object;"))
这个太枯燥了，下面我们用jd_gui看下生成好的字节码是什么样的，挑个sayHello方法吧，除去各种异常处理，方法如下：
public final String sayHello(){ return ((String)this.h.invoke(this, m3, new Object[] { paramString })); }
其中h就是父类Proxy中的属性，m3 = Class.forName("javaDyna.IHello").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });也就是m3是接口中的方法
这个里面有个地方 sayhello没有参数了，这个是jd的问题，请大家不要纠结在这个地方。
通过这一个方法，就可以知道，java动态代理是将所有的方法都委托给了InvocationHandler实现中的invoke方法
了，
看着很简单，呵呵，但是这里面的一些异常，以及缓存的处理还是值得学些的，当然我们只看主干，就行了哈哈
上面就将生成字节码说完了，最后通过 将InvocationHandler的实现传入构造函数，就完成了代理对象的生成，
那时的h才真正是实现。