动态代理（JDK）实现原理

   这几天学习框架，发现动态代理非常值得研究，新知识的补充也打破了之前对代理模式的认知。

1代理模式可以用在什么地方

   之前学习代理模式，主要是大话设计模式。现在又看了一遍大话上讲得代理，真得觉得没有什么养分可以吸收了。其实代理在实际中的用处是很广泛的，是我们必须要认真理解的模式之一。现在我举一个例子，描述代理模式可以用在什么地方。我们有一个类它的功能就是往数据库中批量添加数据，但是现在由于效率问题，我们需要统计一下每次批量添加数据所需要的时间是多少。那现在我们怎么办？最简单的方法就是直接在方法中修改代码。但是我们都知道设计模式的开闭原则。对扩展开放，对修改关闭。这样做很不灵活。这时代理模式就可以帮助我们了。代理对象实现与被代理对象相同的接口，在方法中写入必要的计算时间的代码，也调用被代理对象的批量添加数据方法就可以解决问题了。我们可以拓展一下思路：除了计算批量添加数据的时间，日志、事务等的功能都可以这样附加到实现某些单一功能的类上。

2.代理模式基本UML图

  需要注意得两点：1. RealSubject和Proxy都实现同样的接口   2. Proxy需要持有RealSubject的属性，以调用RealSubject对象的方法。

3.静态代理和动态代理

静态代理是很容易理解的：我们先看一段代码：

Interface:

public interface Moveable {
	void move();
	
}

RealSubject:

public class Tank implements Moveable {

	@Override
	public void move() {
		
		System.out.println("Tank Moving...");
		try {
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

Proxy

public class Tank2 implements Moveable {

	Tank t;
	
	public Tank2(Tank t){
		super();
		this.t = t;
	}
	@Override
	public void move() {
		long start = System.currentTimeMills();
		t.move();
		long end = System.currentTimeMills();
		System.out.println("time:" + end-start);
	}

}

这就是一个静态代理。我们写了一个类来实现功能，在运行前就已经编译好了。每一个代理的可能性都要事先写好。而动态代理就灵活多了。在运行时决定给什么类用什么代理。

我们可以先分析一下静态代理哪里地方需要变成活的。

1.针对接口：例子中实现的Moveable，我们要实现的是可以实现任意接口的代理

2.针对代理具有的功能。例子中实现的是计算时间，我们还可以实现日志、事务等你可以想到的。

这里两点我们要想办法把它得灵活。中间用到反射的技术（目前对反射还没有太多理解）我们来看看动态代理的代码

Proxy

public class Proxy {
	public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
		//参数Class infce 就是需要被代理的类，InvocationHandler 就是指明要实现的是什么代理
		//主要是拼一个字符串Methodstr.内容是重写目标类中的方法。
		String methodStr = "";           
		String rt = "\r\n";
		
		Method[] methods = infce.getMethods();

		for(Method m : methods) {
			methodStr += "@Override" + rt + 
						 "public void " + m.getName() + "() {" + rt +     //m.getName()得到被代理类的方法名称，进行重写
						 "    try {" + rt +
						 "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
						 "    h.invoke(this, md);" + rt +                //调用被代理过的目标方法比如：被计算时间的move方法
						 "    }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;
	}
}

InvocationHandler

public interface InvocationHandler {
	public void invoke(Object o, Method m);
}

TimeHandler

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 {
			m.invoke(target);
		} catch (Exception e) {
			e.printStackTrace();
		}
		long end = System.currentTimeMillis();
		System.out.println("time:" + (end-start));
	}

}

Tank

public class Tank implements Moveable {

	@Override
	public void move() {
		
		System.out.println("Tank Moving...");
		try {
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

Moveable

public interface Moveable {
	void move();
	
}

Client

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();
		
	}
}

最后画一张图对这些代码做个总结：

总结：动态代理的理解有助于我们框架的理解。