我们继续上一篇总结。

上篇我们说到,怎么让before()和after()中的内容也让客户灵活指定?

不管怎么样,我们现在需要一个这样的东西:可以动态指定对方法进行处理的指令。

我们创建一个方法调用的处理器,用来对任意方法进行自定义的处理:

package cn.edu.hpu.proxy;

import java.lang.reflect.Method;

//方法调用的处理器
public interface InvocationHandler {
//你只要给我一个Method方法,我就能对Method进行处理
//做处理的方式是由实现它的子类来决定
//参数:Object o,Method m,即invoke()内要调用对象Object o的Method m方法
public void invoke(Object o,Method m);
}


我们再写一个时间方法的处理类,实现InvocationHandler接口:


package cn.edu.hpu.proxy;

import java.lang.reflect.Method;

public class TimeHandler implements InvocationHandler{


private Object target;

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

//参数是一个方法,我们可以在invoke里在Method方法执行的前后加处理逻辑
@Override
public void invoke(Object o,Method m){
long start=System.currentTimeMillis();
System.out.println("开始时间:"+start+"ms");
try {
m.invoke(target);//执行target类的m方法
} catch (Exception e) {
e.printStackTrace();
}
long end=System.currentTimeMillis();
System.out.println("运行时间:"+(end-start)+"ms");
}

}


这里我们写了一个时间处理的方法调用的处理器



下面就来看我们之前的那段动态代码如何生成。先回顾一下之前的Proxy代码:


package cn.edu.hpu.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) throws Exception{
String methodStr="";
String rt="\r\n";

//使用了Java的反射机制中的getMethods();方法来得到一个类的所有方法
Method[] methods=infce.getMethods();
for (Method m:methods) {
methodStr += rt+" @Override"+rt+
" public void "+m.getName()+"() {"+rt+
" this.before();"+ rt +
" t."+m.getName()+"();"+ rt +
" this.after();"+ rt +
" }"; //返回值通过反射机制也可以拿到,但是比较麻烦,我们这里暂时用void代替
}



String src=
"package cn.edu.hpu.proxy;"+ rt +


"public class TankTimeProxy implements "+infce.getName()+"{"+ rt +
" Moveable t;"+ rt +
" long start;"+ rt +
" long end;"+ rt +


" public TankTimeProxy(Moveable t) {"+ rt +
" super();"+ rt +
" this.t = t;"+ rt +
" }"+ rt +


" public void before(){"+ rt +
" start=System.currentTimeMillis();"+ rt +
" System.out.println(\"开始时间:\"+start+\"ms\");"+ rt +
" }"+

" public void after(){"+ rt +
" end=System.currentTimeMillis();"+ rt +
" System.out.println(\"运行时间:\"+(end-start)+\"ms\");"+ rt +
" }"+ rt +

methodStr+ rt +

"}";

//拿到当前项目的根目录:System.getProperty("user.dir"));
String fileName=System.getProperty("user.dir")
+"/src/cn/edu/hpu/proxy/TankTimeProxy.java";

//我们把src的源码写入自己创建的File文件中去
File f=new File(fileName);
FileWriter fw=new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();

//编译(getSystemJavaCompiler()拿到系统默认的Java编译器,其实就是javac)
JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
//需要一个FileManager,用它来管理文件(参数1:诊断的监听器,参数2、3国际化)
StandardJavaFileManager fileMgr=
compiler.getStandardFileManager(null, null, null);
//通过FileManager找到TankTimeProxy文件,然后放到一个Iterable中
//Iterable是一个数组,用它可以进行迭代
Iterable units=fileMgr.getJavaFileObjects(fileName);
//参数:(输出位置,文件管理器对象,监听器,编译的时候指定的参数,用到那些class文件,需要编译哪些文件)
CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
//进行编译
t.call();
fileMgr.close();

//把编译好的.class文件加载到内存中
//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
URLClassLoader ul=new URLClassLoader(urls);
Class c=ul.loadClass("cn.edu.hpu.proxy.TankTimeProxy");
System.out.println(c);

//得到TankTimeProxy类的构造方法,构造方法的参数为Moveable类型
Constructor ctr=c.getConstructor(Moveable.class);
Object m=ctr.newInstance(new Tank());
return m;

}
}


这一块我们就可以通过实现InvocationHandler接口来完成:


package cn.edu.hpu.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{
String methodStr="";
String rt="\r\n";

//使用了Java的反射机制中的getMethods();方法来得到一个类的所有方法
Method[] methods=infce.getMethods();
for (Method m:methods) {
methodStr += rt+" @Override"+rt+
" public void "+m.getName()+"() {"+rt+
" Method md=null;"+rt+
" try{"+rt+
" md="+infce.getName()+".class.getMethod(\""+m.getName()+"\");"+rt+
" h.invoke(this,md);"+rt+
" }catch(Exception e){"+rt+
" e.printStackTrace();}"+rt+
" }";
}



String src=
"package cn.edu.hpu.proxy;"+ rt +
"import java.lang.reflect.Method;"+ rt +


"public class TankTimeProxy implements "+infce.getName()+"{"+ rt +
" cn.edu.hpu.proxy.InvocationHandler h;"+ rt +


" public TankTimeProxy(InvocationHandler h) {"+ rt +
" super();"+ rt +
" this.h = h;"+ rt +
" }"+ rt +

methodStr+ rt +

"}";

//拿到当前项目的根目录:System.getProperty("user.dir"));
String fileName=System.getProperty("user.dir")
+"/src/cn/edu/hpu/proxy/TankTimeProxy.java";

//我们把src的源码写入自己创建的File文件中去
File f=new File(fileName);
FileWriter fw=new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();

//编译(getSystemJavaCompiler()拿到系统默认的Java编译器,其实就是javac)
JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
//需要一个FileManager,用它来管理文件(参数1:诊断的监听器,参数2、3国际化)
StandardJavaFileManager fileMgr=
compiler.getStandardFileManager(null, null, null);
//通过FileManager找到TankTimeProxy文件,然后放到一个Iterable中
//Iterable是一个数组,用它可以进行迭代
Iterable units=fileMgr.getJavaFileObjects(fileName);
//参数:(输出位置,文件管理器对象,监听器,编译的时候指定的参数,用到那些class文件,需要编译哪些文件)
CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
//进行编译
t.call();
fileMgr.close();

//把编译好的.class文件加载到内存中
//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
URLClassLoader ul=new URLClassLoader(urls);
Class c=ul.loadClass("cn.edu.hpu.proxy.TankTimeProxy");
System.out.println(c);

//得到TankTimeProxy类的构造方法,构造方法的参数为Moveable类型
Constructor ctr=c.getConstructor(InvocationHandler.class);
Object m=ctr.newInstance(h);//之前的Tank()改为InvocationHandler

return m;

}
}


测试:


package cn.edu.hpu.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();
}
}


生成的TankTimeProxy类:


package cn.edu.hpu.proxy;
import java.lang.reflect.Method;
public class TankTimeProxy implements cn.edu.hpu.proxy.Moveable{
cn.edu.hpu.proxy.InvocationHandler h;
public TankTimeProxy(InvocationHandler h) {
super();
this.h = h;
}


@Override
public void move() {
Method md=null;
try{
md=cn.edu.hpu.proxy.Moveable.class.getMethod("move");
h.invoke(this,md);
}catch(Exception e){
e.printStackTrace();}
}
}


测试结果:


class cn.edu.hpu.proxy.TankTimeProxy


开始时间:1436446021225ms


坦克正在移动中...


运行时间:8014ms



可能大家有点晕,看看运行逻辑图:

【动态代理】动态代理Proxy_04_java




其实我们的TankTimeProxy就是JDK动态代理中的$Proxy1类



为了更贴近JDK的动态代理,我们吧原来的TankTimeProxy名字改为$proxy1,即生成的你看不见的加了前后逻辑的动态代理类。


package cn.edu.hpu.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{
String methodStr="";
String rt="\r\n";

//使用了Java的反射机制中的getMethods();方法来得到一个类的所有方法
Method[] methods=infce.getMethods();
for (Method m:methods) {
methodStr += rt+" @Override"+rt+
" public void "+m.getName()+"() {"+rt+
" Method md=null;"+rt+
" try{"+rt+
" md="+infce.getName()+".class.getMethod(\""+m.getName()+"\");"+rt+
" h.invoke(this,md);"+rt+
" }catch(Exception e){"+rt+
" e.printStackTrace();}"+rt+
" }";
}



String src=
"package cn.edu.hpu.proxy;"+ rt +
"import java.lang.reflect.Method;"+ rt +


"public class $Proxy1 implements "+infce.getName()+"{"+ rt +
" cn.edu.hpu.proxy.InvocationHandler h;"+ rt +


" public $Proxy1(InvocationHandler h) {"+ rt +
" super();"+ rt +
" this.h = h;"+ rt +
" }"+ rt +

methodStr+ rt +

"}";

//拿到当前项目的根目录:System.getProperty("user.dir"));
String fileName=System.getProperty("user.dir")
+"/src/cn/edu/hpu/proxy/$Proxy1.java";

//我们把src的源码写入自己创建的File文件中去
File f=new File(fileName);
FileWriter fw=new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();

//编译(getSystemJavaCompiler()拿到系统默认的Java编译器,其实就是javac)
JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
//需要一个FileManager,用它来管理文件(参数1:诊断的监听器,参数2、3国际化)
StandardJavaFileManager fileMgr=
compiler.getStandardFileManager(null, null, null);
//通过FileManager找到TankTimeProxy文件,然后放到一个Iterable中
//Iterable是一个数组,用它可以进行迭代
Iterable units=fileMgr.getJavaFileObjects(fileName);
//参数:(输出位置,文件管理器对象,监听器,编译的时候指定的参数,用到那些class文件,需要编译哪些文件)
CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
//进行编译
t.call();
fileMgr.close();

//把编译好的.class文件加载到内存中
//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
URLClassLoader ul=new URLClassLoader(urls);
Class c=ul.loadClass("cn.edu.hpu.proxy.$Proxy1");
System.out.println(c);

//得到TankTimeProxy类的构造方法,构造方法的参数为Moveable类型
Constructor ctr=c.getConstructor(InvocationHandler.class);
Object m=ctr.newInstance(h);
return m;

}
}


我们这么折腾半天,完成了什么工作呢?


那就是:可以对任意的对象、任意的方法,实现任意的代理。



我们下面来用一下我们自己写的Proxy,看看它是如何方便的:


首先我们写一个接口和接口的实现:


UserMgr.java:
package cn.edu.hpu.ProxyTest;


public interface UserMgr {
void addUser();
}


UserMgrImpl.java:


package cn.edu.hpu.ProxyTest;


public class UserMgrImpl implements UserMgr{


@Override
public void addUser() {
System.out.println("1:插入记录到user表");
System.out.println("2:做日志在另外一张表");
}

}


类似于JavaEE的东西,先不管,我们在addUser()执行了2个操作(由于没有连数据库,直接打印相当于操作了),现在,我们想控制这两个操作(1和2操作)是否同时完成,这叫控制"transaction"(或理解为方法前后做日志)。



原来需要在代码前后加代码,现在我们这么做:


创建一个新的类,叫TransactionHandler,让他去实现我们自己的InvocationHandler


package cn.edu.hpu.ProxyTest;


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


import cn.edu.hpu.proxy.InvocationHandler;


public class TransactionHandler implements InvocationHandler{


private Object target;

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

@Override
public void invoke(Object o, Method m) {
System.out.println("Transaction Start");
try {
m.invoke(target);
}catch (Exception e) {
e.printStackTrace();
}
System.out.println("Transaction Commit");
}


}

我们实现了一个Transaction的处理器。



测试:


package cn.edu.hpu.ProxyTest;


import cn.edu.hpu.proxy.InvocationHandler;
import cn.edu.hpu.proxy.Proxy;


public class Client {
public static void main(String[] args) throws Exception {
UserMgr userMgr=new UserMgrImpl();
InvocationHandler h=new TransactionHandler(userMgr);
UserMgr u=(UserMgr)Proxy.newProxyInstance(UserMgr.class, h);
u.addUser();
}
}


测试结果:


Transaction Start


1:插入记录到user表


2:做日志在另外一张表


Transaction Commit



我两个代理之间也是可以叠加的,可以相互替换的,而且是可插拔的,什么时候不想用哪个代理了,就在配置文件中去掉就行了。这就是动态代理的巨大作用。这就是为什么Spring可以去管理AOP,去管理Transaction,还可以管理其他各种各样的内容。



我们与JDK的动态代理比较一下,JDK的动态代理由两个类构成,第一个叫Proxy:


常用方法:


newProxyInstance(ClassLoader loder,Class<?>[] interfaces,nvocationHandler h)


第一个参数指明需要用哪种ClassLoader把代理类的对象load到内存中。我们自己写的Proxy用


的是URLClassLoad。后面两个参数和我们自己写的newProxyInstance一样。



再看JDK的InvocationHandler:


是一个接口,里面有一个方法:


invoke(Object proxy,Method method,Object[] args)


前两个参数和我们自己写的InvocationHandler一样,最后一个参数指的是调用Method方法时所需要的参数。



动态代理还有一个好处,就是当一个被代理类中有许多的方法需要加前后逻辑,我们仍然只需要按照刚刚的步奏先创建被代理类和InvocationHandler,然后作为参数传进Proxy.newProxyInstance();中即可了。如果按照第一篇总结我们写的那个聚合的,要自己亲手加代码。



动态代理有什么用?事务处理,权限控制,AOP,安全,日志,可以在不该变代码的情况下插入其他功能。



至此,动态代理的设计模式已经总结完毕,大家可以自己动手操作一下,与JDK自己的动态代理作比较,思路会更加清晰。同时感谢马士兵老师的视频教程。