【设计模式】动态代理 && 模拟JDK动态代理

真正理解动态代理需要明白回答以下问题：

什么叫动态代理？怎么产生？

动态代理的作用？可配置的事务，权限控制，日志等等。。。。只有你想不到，没有动态代理做不到。

一、下面来回答以上3个问题：

先说下静态代理：

方法：创建代理类，代理类包含被代理对象的方法并在被代理方法的前后加添加方法。

创建代理类可以用继承接口或者聚合（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();}
}}

固定的InvocationHandler接口（与JDK的原始版本有出入，但是原理一致）：

package com.bjsxt.proxy;

import java.lang.reflect.Method;

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

程序员自己implements InvocationHandler接口在内部指定（Object）表示接受的代理对象（接口）target然后写代理逻辑（在代理对象的方法前后等任意位置自己添加），而方法的调用使用invoke动态的调用。具体代码如下：

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

}

下面在客户端中创建自己的代理对象并创建代理逻辑实例，然后把代理逻辑实例和代理对象接口传入代理类生成代理类实例，最后执行被代理的方法，实现了在目标代码不修改（或者说是不明，例如.class）的情况下，实现在代码切面层功能的自由添加。而且代理类也可以相互包装，因为都继承代理对象接口。

下面附上客户端的调用：

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的方法前后添加了时间日志

三、JDK自带动态代理方法

一、使用JDK的Proxy和InvocationHandler

package com.zhoulei.CrazyJava.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


interface Person {
	void walk();
	void sayHello(String name) ;
}

class MyInvocationHandler implements InvocationHandler {

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("正在执行的方法："+method);
		if(args !=null) {
			
			System.out.println("下面是执行该方法时传入的参数：");
			for(Object val : args) {
				System.out.println(val);
			}
		}else {
			
			System.out.println("调用该方法时无须参数");
		}

		return null;
	}
	
	
}
public class ProxyTest {
	public static void main(String[] args) {

		InvocationHandler handler  = new MyInvocationHandler();
		Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class}, handler);
		p.walk();
		p.sayHello("孙悟空");
		
	}
	
}

二、使用JDK自带动态反射实现AOP

package com.zhoulei.CrazyJava.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Dog {
	
	public void info();
	public void run();
}

class GunDog implements Dog {
	public void info() {
		System.out.println("我是一只狗");
	}
	public void run() {
		
		System.out.println("我奔跑迅速");
	}
}

class MyInvocationHandler2 implements InvocationHandler {
	private Object target ; 
	public void setTarget(Object target) {
		this.target = target;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		System.out.println("——————————模拟第一个通用方法——————————");
		Object result = method.invoke(target, args);
		System.out.println("——————————模拟第二个通用方法——————————");
		return result;
	}
}

class MyProxyFactory{
	//为target 生成动态代理对象
	public static Object getProxy(Object target) {
		MyInvocationHandler2 handler = new MyInvocationHandler2();
		handler.setTarget(target);
		
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
		
		
	}
}

public class MyProxyFactoryTest {
	public static void main(String[] args) {
		Dog target = new GunDog();
		Dog dog = (Dog)MyProxyFactory.getProxy(target);
		dog.info();
		System.out.println();
		dog.run();
		
	}
}

运行结果：

有什么理解有误，或者语言表达不清楚的地方，欢迎批评指正。