设计模式之动态代理

代理模式是23中设计模式中的一种，也是使用很广泛的设计模式。其基本定义是这样的：为其他对象提供一种代理来控制对这个对象的访问。特别适合在某些情况下，某个对象不适合或者不能直接引用另一对象，而代理对象就可以很恰当的起到中介的作用。

代理模式图如右：

即代理类与被代理类实现同一接口，使用聚合方法。

代理分为静态和动态代理，静态代理比较简单，即手动编写代理类，调用被代理的方法，可以直接添加用户的逻辑，简单直观，但是可拓展性不强，故使用不多。

这里主要分析下动态代理。

在JDK中，代理类的API都在java.lang.reflect包中，其常用核心接口类包括InvocationHandler接口和Proxy类，InvocationHandler接口是代理实例的调用处理程序实现的接口，里面只有一个invoke方法，也就是说，这个接口的主要目的就是定义用户自定义的逻辑方法，比如说你向定义一个时间处理的代理，就要创建一个TimeHandle implements  InvocationHandler，并重写invoke方法。而Proxy类中有一个核心常见的方法，newProxyInstance,这个方法用来返回一个指定接口的代理对象，这个接口可以将方法调用指派到指定的调用处理程序。

在动态代理中，代理对象是不会显示出现的，是通过动态编译生成对象，返回后直接封装为为接口对象，调用被代理类的方法。

举个例子，有一个接口sport，里面有一个方法play，一个被代理类football，重写了play方法；

package com.test;

public interface Sport {
	void play();
}

package com.test;

public class Football implements Sport{
	public void play(){
		System.out.println("I play football");
	}
}

声明InvocationHandler接口，声明了用户要求逻辑，再写一个子类Warm_upHandler继承自InvocationHandler，重写invoke方法。

package com.test;

import java.lang.reflect.Method;

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

package com.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Warm_upHandler implements InvocationHandler {

	private Object target;//这是代理对象

	public Warm_upHandler(Object target) {
		super();
		this.target = target;
	}

	public void invoke(Object o, Method m){

		System.out.println("Warm up");
		try {
			m.invoke(target);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

用户要求的逻辑就是在被代理对象前面添加warmup(打球之前先热身)。在用户的Warm_upHandler接口中，需要重写invoke方法，方法参数的是代理对象和实现的方法，这里定义了用户的自定义逻辑。

为了实现动态代理，这里模拟了下JDK里面的proxy类中的newProxyInstance方法，这个方法就是动态返回代理对象。

package com.test;

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 { 
		String methodStr = "";
		String rt = "\r\n";
		
		Method[] methods = infce.getMethods();
		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.test;" +  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.test.InvocationHandler h;" + rt +
			
			
							
			methodStr +
			"}";
		String fileName = 
			"d:/src/com/test/$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.test.$Proxy1");
		System.out.println(c);
		
		Constructor<?> ctr = c.getConstructor(InvocationHandler.class);
		Object m = ctr.newInstance(h);
		//m.move();
		return m;
	}
}

这里简要解释下，返回代理对象的过程，首先是动态代码的生成，根据用户要求的逻辑和代理类，被代理的公共接口，生成代码之后再动态编译，可以根据JDK6提供的动态编译的API:JavaComplier，生成class文件，再把class装载到内存，这里采用了URLClassLoader类，把这个代理类load到内存后，根据反射机制可以获取这个代理类的构造器，生成代理对象并返回，结束。

结果：