java动态代理原理及简单模拟

来源：互联网发布：网络初始化失败编辑：程序博客网时间：2024/05/01 05:13

为跳槽做打算，最近在猛学，回顾一下知识点，突然发现动态代理还是理解的模糊，狠狠研究了一天，写此文以作纪念。
首先写个普通的代理

来个接口：

Java代码  
public interface Drawable {  
      
    public void draw();  
  
}  

再来个实现类：

Java代码  
public class Pen implements Drawable {  
  
    public void draw() {  
        System.out.println("draw something");  
    }  
  
}  

代理类（随便在博客写，未经编译）：

Java代码  
public class ProxyPen implements Drawable{  
private Drawable draw;  
public ProxyPen(Drawable draw){  
this.draw = draw;  
}  
public viod draw(){  
System.out.println("before draw");  
draw.draw();  
}  
}  
//接下来为调用代码  
Drawable pen = new Pen();  
ProxyPen proxy = new ProxyPen(pen);  
proxy.draw();  

以上的静态代理很简单，无非就是聚合+多态。
但是只能代理实现Drawable接口的类，显然具有很大局限性。
而动态代理顾名思义就是动态生成代理类，ProxyPen将根据参数动态生成，要让其动态生成显然必须取得代理的接口，取得接口后能实现代理类，但是代理类添加的内容却还是定死的System.out.println("before draw");这也不满足动态要求，所以代理内容必须也要能自定义，想输任何代理内容，当然还是多态，传入一个处理代理内容的接口Handler即可：
首先定义代理接口：

Java代码  
public interface InvocationHandler {  
        public void invoke(Method m,Object... args) throws Exception;  
}  

Java代码  
public class Proxy {  
  
    public static Object newProxy(Class interfaces,InvocationHandler handler) throws Exception{  
        String r = "\n";  
          
        Method[] methods = interfaces.getMethods();  
          
        StringBuffer sb = new StringBuffer("");  
          
        for(int i =0;i<methods.length;i++){  
            sb.append(" public void "+methods[i].getName()+"() {"+r+  
            "       try{ "+r+  
            "       Method md = "+interfaces.getName()+".class.getMethod(\""+methods[i].getName()+"\");"+r+  
            "       handler.invoke( md,new Object[]{});"+r+  
            "       }catch(Exception e){e.printStackTrace();}"+r+     
            "   }"+r  
            );  
        }  
          
        String src = "package com.javaeye.aronlulu.proxy;"+r+  
                     "import java.lang.reflect.*;"+r+  
        "public class ProxyPen implements "+interfaces.getName() +"{"+r+  
      
        "   private com.javaeye.aronlulu.proxy.InvocationHandler handler;"+r+  
      
        "   public ProxyPen("+handler.getClass().getName()+" handler){"+r+  
        "       this.handler = handler;"+r+  
        "   }"+r+  
System.out.println(\"before\");"+r+  
  
        sb.toString()+  
  
        "}" +r;  
        String dir = System.getProperty("user.dir")+"/src/com/javaeye/aronlulu/proxy/";  
        FileWriter writer = new FileWriter(new File(dir+"ProxyPen.java"));  
        writer.write(src);  
        writer.flush();  
        writer.close();  
        //编译动态代理类  
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();  
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);  
        Iterable units = fileMgr.getJavaFileObjects(dir+"ProxyPen.java");  
        CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);  
        t.call();  
        fileMgr.close();  
                  //加载并调用返回代理接口  
        URL[] urls = new URL[]{new URL("file:/"+dir)};  
        URLClassLoader loader = new URLClassLoader(urls);  
        Class c = loader.loadClass("com.javaeye.aronlulu.proxy.ProxyPen");  
          
        Constructor ctr = c.getConstructor(handler.getClass());  
        return ctr.newInstance(handler);  
          
    }  
      
}  

接下来编写具体处理代理类代码：

Java代码  
public class DrawHandler implements InvocationHandler {  
      
    private Object draw;  
      
    public DrawHandler (Object draw){  
        this.draw = draw;  
    }  
  
    public void invoke(Method m,Object[] args) throws Exception{  
        System.out.println("before");  
        m.invoke(draw, args);  
        System.out.println("after");  
    }  
  
}  

测试代码：

Java代码  
Drawable drawable = new Pen();  
InvocationHandler handler = new DrawHandler(drawable);  
Drawable draw = (Drawable) Proxy.newProxy(Drawable.class,handler);  
draw.draw();  

动态代理的实现简单完成了，当然跟java的动态代理实现没法比，中间还封装了很多类型检查及反射实现。动态代理原理其实无非就是反射+多态+聚合的实现，当然有了动态代理，很多强大的功能就能实现了，最有名的无非就是AOP,java动态代理的局限性是只能针对接口，若要针对具体业务类，则需要CGLIB这样的第三方框架了，springAOP则采用了以上两种组合，默认还是使用java动态代理，设置Bean中一个属性开关来控制，若非接口实现，则开始调用CGLIB。

0 0