java代理模式分析

最新推荐文章于 2025-01-07 09:00:00 发布

转载最新推荐文章于 2025-01-07 09:00:00 发布 · 243 阅读

首先来谈为什么需要代理。

比如我有一个接口如下

[java]view plaincopy 
   
 public interface Moveable {  
     void move();  
       
 }  

它有一个move方法。现在我有这样一个需求，当我要通过子类实现该接口调用move方法的时候，我想在move方法的前后加一些逻辑
比如加日志、事务、权限等。我不想改变或者有时候我们没有源码没法改变move方法的时候，这时候我们可以让一个代理类帮我们做类似这样的事情。

因此我们先从静态代理说起。先建一个Moveable接口的实现类

[java]view plaincopy 
   
 import java.util.Random;  
   
   
 public class Tank implements Moveable {  
   
     @Override  
     public void move() {  
           
         System.out.println("Tank Moving...");  
         try {  
             Thread.sleep(new Random().nextInt(10000));  
         } catch (InterruptedException e) {  
             e.printStackTrace();  
         }  
           
     }  
   
       
       
 }  

然后我们再建一个代理类LogProxy

[java]view plaincopy 
   
   

[java]view plaincopy 
   
 public class LogProxy implements Moveable {  
     private Moveable moveable;  
     public LogProxy(Moveable moveable) {  
         this.moveable = moveable;  
     }  
   
     @Override  
     public void move() {  
         System.out.println("Tank move begin......");  
         moveable.move();  
         System.out.println("Tank move end......");  
           
     }  
   
       
   
 }  

让它实现Moveable接口，并且持有Tank类的引用也就是实现Moveable接口的子类。重写move方法，并在其前后加日志逻辑。这样一个静态代理类就写好了。下面我们看客户

端调用代码。

[java]view plaincopy 
   
 public class Client {  
     public static void main(String[] args) throws Exception {  
         Tank t = new Tank();  
         Moveable m = (Moveable)new LogProxy(t);  
           
         m.move();  
     }  
 }  

打印结果：

Tank move begin......
Tank Moving...
Tank move end......

静态代理是有缺陷的，如果我想给Tank加一个其他逻辑的代理，那么我需要再新建一个代理类,并实现Moveable接口。这样不够灵活也不够方便。我们想要这样一个代理，它可以代理实现任何接口的对象的任何方法。而不是像静态代理那样只能代理实现Moveable接口的move方法,那么下面我们就来看动态代理。

在分析动态代理之前我们来看一下JDK自带的动态代理如何使用，还是以上面的Moveable接口、Tank类为例。我们先建一个日志逻辑处理类LogHandler实现InvocationHandler接口。

[java]view plaincopy 
   
 import java.lang.reflect.InvocationHandler;  
 import java.lang.reflect.Method;  
 public class LogHandler implements InvocationHandler {    
     private Object target;  
     public LogHandler(Object target) {    
         this.target = target;     
     }  
     @override  
     public Object invoke(Object proxy, Method method, Object[] args)  
             throws Throwable {  
         //目标方法前的逻辑  
         System.out.println("start......" );  
           
         Object ret = null;  
         try {  
             //调用目标方法，本例中会调用move方法，这里用到反射技术  
             ret = method.invoke(target, args);  
               
         }catch(Exception e) {  
             e.printStackTrace();  
             throw e;  
         }//目标方法后的逻辑  
                 System.out.println("end.....");  
         return ret;  
     }  
 }  

然后客户端代码如下：

[java]view plaincopy 
   
 import java.lang.reflect.Proxy;  
 public class Client {  
     public static void main(String[] args) {  
         //委托类对象  
         Moveable mgr = new Tank();   
         //处理类对象  
         LogHandler h = new LogHandler(mgr);  
         //代理类Proxy生一个实现了Moveable接口，并且包含新增了LogHandler处理逻辑的代理对象m  
         Moveable m = Proxy.  
             newProxyInstance(mgr.getClass().getClassLoader(), mgr.getClass().getInterfaces(), h);  
         m.move();  
     }  
 }  

这样加了日志逻辑的move方法运行结果如下：
start......
Tank Moving...
end......

下面我们来分析一下Proxy以及它的newProxyInstance(...)方法都干了些什么……
我借用尚学堂马士兵的Proxy代码来说明这个问题。

[java]view plaincopy 
   
 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(ClassLoader loader,Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM  
         String methodStr = "";  
         String rt = "\r\n";  
         //利用反射，获得infce接口中方法，本例中就是获得Moveable接口的方法move  
         Method[] methods = infce.getMethods();  
         //拼接infce中所有方法字符串，用来重写infce中的方法，本例中拼出来就是重写的move方法  
         for(Method m : methods) {  
             methodStr += "@Override" + rt +   
                          "public void " + m.getName() + "() {" + rt +  
                          "    try {" + rt +  
                          "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +  
                         /*方法最核心的代码，h是构造$Proxy1时传入的handler,本例中就是LogHandler对象,new Object[] { null}是move方法需要的参数，本例不需要,故为空。这一步将会使我们编写的处理类逻辑LogHandler的invoke方法得到调用。从而达到我们最初要在move方法前加日志逻辑的的目的,下面要做的就是把我们拼好的字符串生成类并load到内存就可以了这样就实现了动态生成代理类并加自己想加的逻辑*/  
                          "    h.invoke(this, md,new Object[] { null});" + rt +  
                          "    }catch(Exception e) {e.printStackTrace();}" + rt +  
                           
                          "}";  
         }  
           
         String src =   
             "package com.bjsxt.proxy;" +  rt +  
             "import java.lang.reflect.Method;" + rt +  
             //这里动态实现infce接口，本例中就是Moveable,构造方法中让Proxy持有处理类Handler的引用  
             "public class $Proxy1 implements " + infce.getName() + "{" + rt +  
             "    public $Proxy1(InvocationHandler h) {" + rt +  
             "        this.h = h;" + rt +  
             "    }" + rt +  
               
               
             "    com.bjsxt.proxy.InvocationHandler h;" + rt +  
             //这里是需要重写Moveable中的方法，见上面该字符串的拼接过程                
             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);  
           
         //利用反射，这里就返回一个实现了infce接口也就是本例中Moveable接口的代理对像$Proxy1  
         return m;  
     }  
 }  