动态代理模式分析--基于马士兵视频例子

代码改天上传。现在上传不上来、、
[b]关于模式之外的代码准备:动态编译[/b]
Java作为动态语言的特点，这里要做的就是，通过代码来把一个存有java代码的简单的小程序写入到一个java文件中，然后调用java的CompilationTask对其进行编译并实例化，接下来自然就是调用运行了。
大体流程：
1． 组织字符串，也就是要生成的java问的代码
2． 写入到文件中去，名字暂时定为：ProxyStart.java ，package为learn
3． 获取jdk编译器
4． 拿到编译任务，进行编译
5． 找到编译之后的类，加载这个class类文件到内存
6． 通过反射对这个类实例化。并调用》

代码：test1.java

public class test1 {
	public static void main(String[] args) throws Exception {
		String src = "package learn;	" +
				"public class ProxyStart implements Moveable{" +
				"Moveable m = null;" +
				"public ProxyStart(Moveable m){" +
				"this.m = m;System.out.println(\"ok\");" +
				"}" +
				"public void move() {" +
				"System.out.println(\"ok\");" +
				"m.move();}}";

		String filePath = System.getProperty("user.dir");
		System.out.println(filePath);

		String fileName = System.getProperty("user.dir")
					+"/src/learn/ProxyStart.java";

		File f = new File(fileName);
		FileWriter fw = new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();

		//获取jdk编译器
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
//		System.out.println(compiler);
		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();
		System.out.println("f");

		//加载某个class类文件
		URL[] urls = new URL[]{new URL("file:/"+filePath+"/src")};
		URLClassLoader url = new URLClassLoader(urls);
		Class c = url.loadClass("learn.ProxyStart");
		System.out.println(c);//输出  class learn.TankTimeProxyStart

		//操作这个加载到内存的类
		//拿到构造方法参数为moveable的构造方法
		Constructor ctr =  c.getConstructor(Moveable.class);
		Moveable m = (Moveable) ctr.newInstance(new Tank());
		m.move();
	}
}

新的知识点：

1.	String filePath = System.getProperty("user.dir");
这个是为了得到这个工程所在的目录。
2.	这里是通过这个来写入到java文件的，没有出现乱码，如果有乱码，再特殊处理。如果为了可移植的话，最好采用DataInputStream这个是跟操作系统无关的文件流实现
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
3.	获得jdk编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
//		System.out.println(compiler);
StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
Iterable  units = fileMgr.getJavaFileObjects(fileName);
4.	拿到编译任务
CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
t.call();//编译
fileMgr.close();
System.out.println("f");
5.	加载类到内存
		//加载某个class类文件
		URL[] urls = new URL[]{new URL("file:/"+filePath+"/src")};
		URLClassLoader url = new URLClassLoader(urls);
		Class c = url.loadClass("learn.TankTimeProxy");
		System.out.println(c);//输出  class learn.TankTimeProxy
6.	通过构造方法对其进行实例话
		//操作这个加载到内存的类
		//拿到构造方法参数为moveable的构造方法
		Constructor ctr =  c.getConstructor(Moveable.class);
		Moveable m = (Moveable) ctr.newInstance(new Tank());
m.move();

7. 以上除了第6个，其他基本都是不用怎么修改的。有时间写成一个工具类。。。
[b]简单代理[/b]
首先定一个接口，这里是Moveable接口，里面有一个Move()方法。接下来会有一个已经定义好的类实现这个接口，并假设这个类是不能修改的了，可是他的功能不能够完全胜任现在的工作，比如要测试他的运行时间，。。那么怎么给他添加功能呢。
方法1：对这个类写一个继承类，在覆盖父类的这个方法，
Move(){
//do something before ，here is count the start time
Super().move()
//do something after , here is count the end time and calculate the time spend
}
但这样的话，要对每个需要添加新功能的，都需要计算时间的话，要每一个都继承出一个子类
这里就用到了开始的动态编译功能，我要根据他们公共的接口，生成一个新的类，这个类实现了Moveable接口，在其内部的move方法前后添加 计算时间的代码，中间是调用要 测试的类（当然这些类也实现了Moveable接口）
Moveable接口 --- 略
Tank 类 -------Moveable接口的实现类 略
ProxySecond 代理类的生成类 – 除了拼接字符串以外，其他与刚刚开始的动态编译代码都一样，其实上边的例子就是取得这里的代理类生成类。

		String src = "package learn;	" +
				"public class ProxyStart implements Moveable{" +
				"Moveable m = null;" +
				"public ProxyStart(Moveable m){" +
				"this.m = m; "+
"System.out.println(\"ok\");" +
				"}" +
				"public void move() {" +
				"System.out.println(\"ok\");" +
				"m.move();}}";

可以看到，这个字符串将会是生成的代理类，有一个Moveable参数的构造方法，将要测试的Moveable实现类（这里是tank类）的实例对象传到代理类中，代理类中为m，由于代理类也实现了Moveable方法，我们可以通过实例化代理类来调用Move()方法，也是因为这样，我们在代理类的Move()方法中调用m.move(),这就相当于间接调用了tank的move方法，我们在m.move()前后添加计算运行时间的代码，就可以对这个tank运行时间的测试，若是要测试其他所有实现了Moveable接口的类的运行时间，只需要在对代理类实例化时调用的构造方法中传递个实例进去就行了。代码为
Tank类的测试

Constructor ctr =  c.getConstructor(Moveable.class);
Moveable m = (Moveable) ctr.newInstance(new Tank());
m.move()

其他实现了Moveable类的测试

Constructor ctr =  c.getConstructor(Moveable.class);
Moveable m = (Moveable) ctr.newInstance(new OtherMoveAbleObject());
m.move()

[b]动态代理的实现—准备[/b]
上面的简单代理是针对某个特定接口来实现的。对于实现不同的接口的类的测试，还是要不断的重复。经过分析代理类的代码发现，对于不同的接口,我们要修改的只不过是接口的实现方法，在实现方法中调用一个接口方法，都是具有很大的共性.由于java的反射机制，我们完全可以对其进行支持任意接口的处理，
这里我们需要获得这个接口的方法列表，这个容易，我们已经得到了实现这个接口的实例tank，我们对其进行反射处理，得到他所有的方法，然后通过forEach拼字符串，恩，拼完字符串，也就结束了，太简单了就不放代码了。

[b]动态代理的实现—实现[/b]
接下来还有什么？恩，我们假如要修改需求呢，我们不做运行时间的测试了，我们要做日志、我还要做事务、我还想事务+日志+时间测试。。任意组合。这样的话，我们就需要把生成代理类的业务实现代码拿到外边来实现，那么这些代码拿到哪里好呢？？
先不做探索放在哪里好，到这里也是动态代理要实现的功能了。我们看动态代理的选择。我们通过上边的代码可以发现，
a.代理类里边实现的是接口的方法，
b.方法里面调用的是被代理类的接口方法，
c.被调用的时候也是接口的方法，
；我们可不可以在(b)实现了接口的方法里面不去调用被代理类的接口，而是(d)调用一个中间过程的类（或接口）的方法，这个中间过程来调用被代理类。
代码示例:
1.接口 …implement moveable{//a. 被代理类的接口
……………..
….Move(){//c. 被代理类的接口的实现方法
//do something before and after
m.move();//b. call被代理类的接口实现方法
}
被调用时
Moveable p = new ProxySecond(new Tank());
p.move()
2.接口….implement moveable{
………move(){
//d. do other method,the one who will call the move method
}
被调用还是p.move()

貌似这个中间过程也可以通过代理来实现，恩，应该可以，不过如果再次采用代理的话，，代理得太乱了就，我们看看有没有简单点的实现（为了简单，这个中间过程只做一件具体的业务,接口中只有一个方法，比如处理时间，只做时间；处理日志，只做日志…）。
先不管能不能实现，我们先去实现这个接口再说，这个接口我们还是以计算开始结束时间为例，在接口HandlerProxy中写一个doAround()方法。然后实现这个接口，TimeHandlerProxy类中，构造方法是获得要被代理的对象，在这里假设是tank类：
/**
* 要被代理的对象
*/
private Object object;
public TimeProxyHandler(Object object) {
this.object = object;
}
我们知道反射里有一个invoke方法，可以调用一个对象中的方法,我们已经得到了tank对象，那么很容易就可以调用他的Move方法并添加时间

	/**
	 * 在代理对象的方法执行前后；执行时间统计方法，
	 */
	@Override
	public void doAround(Object obj) throws Exception {
		//注意，这里假如接口中有多个方法的话，这里再添加一个参数、可以使Method m，
也可以是String MethodName;这里为了逻辑简单，并没有加，实际上是有的
		//在计算时间的里面逻辑上没有用到obj，只是用类做一下输出,利于理解逻辑
		long start = System.currentTimeMillis();
		System.out.println("start:\t" + start + "obj.getClass().getName()");
		//method 要被执行的方法
		//object method是这个object一个方法
		//没有参数，有参数是：method.invoke(model, "参数"...);
		Method method = object.getClass().getMethod("move", null);
		method.invoke(object);

		long end = System.currentTimeMillis();
		System.out.println("end:\t" + end);
		System.out.println("time: \t" + (end-start));
	}

在代理类中，添加一个参数，这个参数就是中间部分接口（这里的理由说起来很绕，具体看代码。我们先假设现在的动态代理类是ProxyProcedure，我们用它生成的代理类名为TankTimeProxy,中间部分接口为HandlerProxy；因为我们要在生成的代理类TankTimeProxy中实现的接口move方法里面调用doAround方法,所以要实例化一个中间类,即HandlerProxy的实现类，HandlerProxy h = null,我们这里打算要通过构造方法来引入HandlerProxy的实现类,而我们这个TankTimeProxy的实例化是通过下边的动态编译来进行的，下边动态编译的代码部分就要传入TankTimeProxy需要的接口,也就是HandlerProxy，我们这时候传入的doProxy(Class inter, ProxyHandler h)的h就是用在这里:
Constructor ctr = c.getConstructor(h.getClass().getInterfaces());
Object m = (Object) ctr.newInstance(h);
Return m）