设计模式之代理模式(3)
观看这篇文章前，请先阅读设计模式之代理模式(1)
静态代理会发生类爆炸？那jdk的使用的动态代理到底是怎么做到的呢?我来大概模拟一下jdk的动态代理。
这是我的目录结构：（可先跳过代码，到最下面听下我的BB,在对照代码来看！）
我先来介绍一下这些兄弟：
Tank:
package cn.asto.proxy; import java.util.Random; public class Tank implements Moveable{ public void move(){ System.out.println("Tank is moving..."); try { Thread.sleep(new Random(47).nextInt(10000)); } catch (InterruptedException e) { e.printStackTrace(); } } }
Moveable:
package cn.asto.proxy; public interface Moveable { public void move(); }
InvocationHandler（一个接口）：
package cn.asto.proxy; import java.lang.reflect.Method; public interface InvocationHandler { public void invoke(Object o,Method m); }
TimeHandler(实现了InvocationHandler的接口)
package cn.asto.proxy; import java.lang.reflect.Method; public class TimeHandler implements InvocationHandler{ private Object target; public TimeHandler(Object target){ this.target = target; } @Override public void invoke(Object o, Method m) { long startTime = System.currentTimeMillis(); System.out.println("startTime:"+startTime); try { m.invoke(target,null); } catch (Exception e) { e.printStackTrace(); } long endTime = System.currentTimeMillis(); System.out.println("Time:"+(endTime-startTime)); } }
Proxy（总代理）：
package cn.asto.proxy; 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.JavaCompiler.CompilationTask; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; public class Proxy { public static Object getProxyInstance(Class inface,InvocationHandler h) throws Exception{ String rt ="\r\t"; String methodStr = ""; // for(Method m:inface.getMethods()){ // methodStr+=" @Override" + rt+ // " public void " + m.getName() + "(){" + rt + // " long startTime = System.currentTimeMillis();"+ rt + // " System.out.println(\"startTime:\"+startTime);"+ rt + // " t." + m.getName() + "()" + ";"+ rt + // " long endTime = System.currentTimeMillis();"+ rt + // " System.out.println(\"Time:\"+(endTime-startTime));"+ rt + // // " }" + rt; // // } for(Method m : inface.getMethods()) { methodStr += "@Override" + rt + "public void " + m.getName() + "() {" + rt + " try {" + rt + " Method md = " + inface.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt + " h.invoke(this, md);" + rt + " }catch(Exception e) {e.printStackTrace();}" + rt + "}"; } String str = "package cn.asto.proxy;"+ rt + "import java.lang.reflect.Method;" + rt + "public class TankTimeProxy implements " +inface.getName()+ "{"+ rt + " cn.asto.proxy.InvocationHandler h;" + rt + " public TankTimeProxy(InvocationHandler h) {"+ rt + " super();"+ rt + " this.h = h;"+ rt + "}"+ rt + methodStr+ "}"; String fileName =System.getProperty("user.dir")+"/src/cn/asto/proxy/TankTimeProxy.java"; FileWriter fw = new FileWriter(fileName); fw.write(str); 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:/"+System.getProperty("user.dir")+"/src/"))}; URLClassLoader ul = new URLClassLoader(urls); Class c = ul.loadClass("cn.asto.proxy.TankTimeProxy"); System.out.println(c); Constructor ctr = c.getConstructor(InvocationHandler.class); Object m = (Object)ctr.newInstance(h); return m; } }
Test1:
package cn.asto.compiler.test; import cn.asto.proxy.InvocationHandler; import cn.asto.proxy.Moveable; import cn.asto.proxy.Proxy; import cn.asto.proxy.Tank; import cn.asto.proxy.TimeHandler; public class Test1 { public static void main(String args[]) throws Exception{ Tank t = new Tank(); InvocationHandler h = new TimeHandler(t); Moveable m = (Moveable)Proxy.getProxyInstance(Moveable.class, h); m.move(); } }
大概思路就是将代理添加的逻辑代码和基类抽象出来，我们都知道所有的代理类（以及基类实现一个接口），并且为了提高逻辑代码的重用性，我们将这两部分抽象成InvocationHandler和XXX.class.（xxx表示代理和基类实现的接口，这里是指Moveable）,
写一个TimeHandler类，传入一个代理或者基类，实现InvocationHandler接口，将实现类和xxx.class作为Proxy的构造参数传入，在Proxy大概做那么几件事情，动态生成代理类文件（.java），编译，将InvocationHandler的实现类传入到动态代理文件的构造函数中，构造代理类。（这里有一个回调的过程），让动态代理类去回调InvocationHandler的实现类中的具体逻辑代码（invoke方法）,而invoke调用的就是传给InvocationHandler实现类的构造参数类的需要实现逻辑代码添加的方法的基础上，加上逻辑代码。
（总代理生成动态代理类，回调handler,handler回调move）
现在让我们来做一个实验，验证动态代理类可以实现代理任意的对象和任意的逻辑方法体（InvocationHandler）
新建一个User接口:
package cn.asto.proxy.user; public interface UserMgr { public void addUser(); }
建一个User类：
package cn.asto.proxy.user; public class User implements UserMgr{ @Override public void addUser() { System.out.println("添加用户"); } }
在建一个LoginHandler
package cn.asto.proxy.user; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import cn.asto.proxy.InvocationHandler; public class LoginHandler implements InvocationHandler{ private Object target; public LoginHandler(Object target) { super(); this.target = target; } @Override public void invoke(Object o, Method m) { System.out.println("登录成功"); try { m.invoke(target, null); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
在Client中进行调用:
package cn.asto.proxy.user; import cn.asto.proxy.Proxy; public class Client { public static void main(String args[]){ User u = new User(); LoginHandler l = new LoginHandler(u); try { UserMgr ur = (UserMgr)Proxy.getProxyInstance(UserMgr.class, l); ur.addUser(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
打印输出：
登录成功
添加用户
测试完成！
好让我来看看jdk的代理程序：
package cn.asto.jdk; import java.lang.reflect.Proxy; import cn.asto.proxy.user.UserMgr; public class Client { public static void main(String args[]){ User u = new User(); LoginHandler l = new LoginHandler(u); ClassLoader c = ClassLoader.getSystemClassLoader(); try { UserMgr ur = (UserMgr)Proxy.newProxyInstance(c,new Class[]{UserMgr.class}, l); ur.addUser(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
package cn.asto.jdk; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class LoginHandler implements InvocationHandler { private Object target; public LoginHandler(Object target) { super(); this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("登录成功"); try { method.invoke(target, null); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } }
package cn.asto.jdk; import cn.asto.proxy.user.UserMgr; public class User implements UserMgr{ @Override public void addUser() { System.out.println("添加用户"); } }
package cn.asto.proxy.user; public interface UserMgr { public void addUser(); }
不用看了，基本和我实现得差不多。只不过换成了jdk的InvocationHandler和jdk的Proxy.newProxyInstance
总结：代理可以完成代码块的插拔叠加！什么意思呢？spring中aop不就是这样子吗？ 拦截器？ 登录校验？权限控制？
