动态生成源代码后动态编译成字节码

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

来个接口：

Java代码  

1. public interface Drawable {  
2.       
3.     public void draw();  
4.   
5. }  

再来个实现类：

Java代码  

1. public class Pen implements Drawable {  
2.   
3.     public void draw() {  
4.         System.out.println("draw something");  
5.     }  
6.   
7. }  

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

Java代码  

1. public class ProxyPen implements Drawable{  
2. private Drawable draw;  
3. public ProxyPen(Drawable draw){  
4. this.draw = draw;  
5. }  
6. public viod draw(){  
7. System.out.println("before draw");  
8. draw.draw();  
9. }  
10. }  
11. //接下来为调用代码  
12. Drawable pen = new Pen();  
13. ProxyPen proxy = new ProxyPen(pen);  
14. proxy.draw();  

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

Java代码  

1. public interface InvocationHandler {  
2.         public void invoke(Method m,Object... args) throws Exception;  
3. }  

Java代码  

1. public class Proxy {  
2.   
3.     public static Object newProxy(Class interfaces,InvocationHandler handler) throws Exception{  
4.         String r = "\n";  
5.           
6.         Method[] methods = interfaces.getMethods();  
7.           
8.         StringBuffer sb = new StringBuffer("");  
9.           
10.         for(int i =0;i<methods.length;i++){  
11.             sb.append(" public void "+methods[i].getName()+"() {"+r+  
12.             "       try{ "+r+  
13.             "       Method md = "+interfaces.getName()+".class.getMethod(\""+methods[i].getName()+"\");"+r+  
14.             "       handler.invoke( md,new Object[]{});"+r+  
15.             "       }catch(Exception e){e.printStackTrace();}"+r+     
16.             "   }"+r  
17.             );  
18.         }  
19.           
20.         String src = "package com.javaeye.aronlulu.proxy;"+r+  
21.                      "import java.lang.reflect.*;"+r+  
22.         "public class ProxyPen implements "+interfaces.getName() +"{"+r+  
23.       
24.         "   private com.javaeye.aronlulu.proxy.InvocationHandler handler;"+r+  
25.       
26.         "   public ProxyPen("+handler.getClass().getName()+" handler){"+r+  
27.         "       this.handler = handler;"+r+  
28.         "   }"+r+  
29. System.out.println(\"before\");"+r+  
30.   
31.         sb.toString()+  
32.   
33.         "}" +r;  
34.         String dir = System.getProperty("user.dir")+"/src/com/javaeye/aronlulu/proxy/";  
35.         FileWriter writer = new FileWriter(new File(dir+"ProxyPen.java"));  
36.         writer.write(src);  
37.         writer.flush();  
38.         writer.close();  
39.         //编译动态代理类  
40.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();  
41.         StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);  
42.         Iterable units = fileMgr.getJavaFileObjects(dir+"ProxyPen.java");  
43.         CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);  
44.         t.call();  
45.         fileMgr.close();  
46.                   //加载并调用返回代理接口  
47.         URL[] urls = new URL[]{new URL("file:/"+dir)};  
48.         URLClassLoader loader = new URLClassLoader(urls);  
49.         Class c = loader.loadClass("com.javaeye.aronlulu.proxy.ProxyPen");  
50.           
51.         Constructor ctr = c.getConstructor(handler.getClass());  
52.         return ctr.newInstance(handler);  
53.           
54.     }  
55.       
56. }  

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

Java代码  

1. public class DrawHandler implements InvocationHandler {  
2.       
3.     private Object draw;  
4.       
5.     public DrawHandler (Object draw){  
6.         this.draw = draw;  
7.     }  
8.   
9.     public void invoke(Method m,Object[] args) throws Exception{  
10.         System.out.println("before");  
11.         m.invoke(draw, args);  
12.         System.out.println("after");  
13.     }  
14.   
15. }  

测试代码：

Java代码  

1. Drawable drawable = new Pen();  
2. InvocationHandler handler = new DrawHandler(drawable);  
3. Drawable draw = (Drawable) Proxy.newProxy(Drawable.class,handler);  
4. draw.draw();  

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