标签：proxy invocationhandler 动态代理 设计模式
真正理解动态代理需要明白回答以下问题：
什么叫动态代理？怎么产生？
动态代理的作用？可配置的事务，权限控制，日志等等。。。。只有你想不到，没有动态代理做不到。
先说下静态代理：
方法：创建代理类，代理类包含被代理对象的方法并在被代理方法的前后加添加的方法。
创建代理类可以用继承接口或者聚合（implements）被代理对象的接口来实现，然后传入被代理对象的实例。其中聚合并继承好，使用继承的时候如果代理类需要嵌套代理类或者创建不同的代理类，需要创建不同的代理类。造成类泛滥。
而聚合即使用接口实现的方式相对更好更灵活，因为每个代理类都继承被代理对象的接口的话，只需在某个代理类中传入不同的代理实例 就可以实现不同的代理，这样可以自由组合。
但是静态代理仍然有缺点，实现代理功能需要自己手写代理类和逻辑，而且要实现多个不同的代理功能，还是需要写多个代理类。
所以要想办法将代理类Proxy的代码固定，然后动态的传入需要代理的对象和并且把代理的逻辑直接传进去。这样代理类Proxy，就可以固定不变了。就这是所谓的动态的意思。而代理是指为其他对象提供一种代理以控制对这个对象的访问 ，即在目标对象的内部插入自己定其它功能，而不需要修改对象内部的代码（或者说结构）。
总结来看，就是我们不需要动被代理对象的代码而能对任意的对象、接口方法、实现任意的代理（自定义）。
为了说明动态代理的优点和以及JDK动态代理的原理：
我来模拟一下，JDK动态代理的实现过程：
为了Proxy代码固定，并实现动态的效果
我们使用Java Complier将字符流（为了简单自己定义字符）编译成.class源代码到工作目录（或者自定义的目录），然后把class对象load进内存生成一个类，这里创建类的时侯，构造方法传入的是代理逻辑，而此处的类就是被代理的接口。两者在客户端调用的时候都是动态指定的。
下面附上Proxy动态生成的代码：
package com.bjsxt.proxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
public class Proxy {
public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
String methodStr = "";
String rt = "\r\n";
Method[] methods = infce.getMethods();
/*
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
" long start = System.currentTimeMillis();" + rt +
" System.out.println(\"starttime:\" + start);" + rt +
" t." + m.getName() + "();" + rt +
" long end = System.currentTimeMillis();" + rt +
" System.out.println(\"time:\" + (end-start));" + rt +
"}";
}
*/
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
" try {" + rt +
" Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
" h.invoke(this, md);" + rt +
" }catch(Exception e) {e.printStackTrace();}" + rt +
"}";
}
String src =
"package com.bjsxt.proxy;" + rt +
"import java.lang.reflect.Method;" + rt +
"public class $Proxy1 implements " + infce.getName() + "{" + rt +
" public $Proxy1(InvocationHandler h) {" + rt +
" this.h = h;" + rt +
" }" + rt +
" com.bjsxt.proxy.InvocationHandler h;" + rt +
methodStr +
"}";
String fileName =
"d:/src/com/bjsxt/proxy/$Proxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//compile
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMgr.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
t.call();
fileMgr.close();
//load into memory and create an instance
URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.bjsxt.proxy.$Proxy1");
System.out.println(c);
Constructor ctr = c.getConstructor(InvocationHandler.class);
Object m = ctr.newInstance(h);//通过构造方法生成对象
//m.move();
return m;
}
}
此处的Moveable就是我们指定的代理对象（这个对象是代理目标的意思，不是实例对象）的接口，意味着传入的不是代理对象的实例而是代理对象和代理类共同的接口，而InvocationHandler也是代理逻辑的接口，InvationHandler也是写死的（这也是灵活之处，这样可以将不同的代理逻辑配置在配置文件中（多态）），不需要变动。
package com.bjsxt.proxy;
import java.lang.reflect.Method;
public class $Proxy1 implements com.bjsxt.proxy.Moveable{
public $Proxy1(InvocationHandler h) {
this.h = h;
}
com.bjsxt.proxy.InvocationHandler h;
@Override
public void move() {
try {
Method md = com.bjsxt.proxy.Moveable.class.getMethod("move");
h.invoke(this, md);
}catch(Exception e) {e.printStackTrace();}
}}package com.bjsxt.proxy;
import java.lang.reflect.Method;
public interface InvocationHandler {
public void invoke(Object o, Method m);
}
package com.bjsxt.proxy;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler{
private Object target;
public TimeHandler(Object target) {
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
//自己的代理逻辑
long start = System.currentTimeMillis();
System.out.println("starttime:" + start);
System.out.println(o.getClass().getName());
try {
//调用target.m方法，这样可以处理任何的类，任何的方法（传进来的）
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("time:" + (end-start));
}
}
下面附上客户端的调用：
package com.bjsxt.proxy;
public class Client {
public static void main(String[] args) throws Exception {
Tank t = new Tank();
InvocationHandler h = new TimeHandler(t);
Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);
m.move();
}
}
//可以对任意的对象、任意的接口方法，实现任意的代理程序的运行结果如下：在moveable方法前后添加了时间日志
有什么理解有误，或者语言表达不清楚的地方，欢迎批评指正。
标签：proxy invocationhandler 动态代理 设计模式
原文地址：http://blog.csdn.net/aiwuzhiling/article/details/39298695
