Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码JBoss 应用服务器项目,通过使用Javassist对字节码操作为JBoss实现动态AOP框架。javassist是jboss的一个子项目，其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。

下面通过Javassist创建上述的Programmer类：

  1. import javassist.ClassPool;
  2. import javassist.CtClass;
  3. import javassist.CtMethod;
  4. import javassist.CtNewMethod;
  6. public class MyGenerator {
  8.     public static void main(String[] args) throws Exception {
  9.         ClassPool pool = ClassPool.getDefault();
  10.         //创建Programmer类        
  11.         CtClass cc= pool.makeClass("com.samples.Programmer");
  12.         //定义code方法
  13.         CtMethod method = CtNewMethod.make("public void code(){}", cc);
  14.         //插入方法代码
  15.         method.insertBefore("System.out.println(\"I'm a Programmer,Just Coding.....\");");
  16.         cc.addMethod(method);
  17.         //保存生成的字节码
  18.         cc.writeFile("d://temp");
  19.     }
  20. }

通过JD-gui反编译工具打开Programmer.class 可以看到以下代码：
Mybatis之Javassist字节码生成开源框架 - 图1

代理的基本构成：

代理模式上，基本上有Subject角色，RealSubject角色，Proxy角色。其中：Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务。
Mybatis之Javassist字节码生成开源框架 - 图2
上面的这幅代理结构图是典型的静态的代理模式：

  1.    当在代码阶段规定这种代理关系，Proxy类通过编译器编译成class文件，当系统运行时，此class已经存在了。这种静态的代理模式固然在访问无法访问的资源，增强现有的接口业务功能方面有很大的优点，但是大量使用这种静态代理，会使我们系统内的类的规模增大，并且不易维护；并且由于Proxy和RealSubject的功能 本质上是相同的，Proxy只是起到了中介的作用，这种代理在系统中的存在，导致系统结构比较臃肿和松散。




为了解决这个问题，就有了动态地创建Proxy的想法：在运行状态中，需要代理的地方，根据Subject 和RealSubject，动态地创建一个Proxy，用完之后，就会销毁，这样就可以避免了Proxy 角色的class在系统中冗杂的问题了。

下面以一个代理模式实例阐述这一问题：

将车站的售票服务抽象出一个接口TicketService,包含问询，卖票，退票功能，车站类Station实现了TicketService接口，车票代售点StationProxy则实现了代理角色的功能，类图如下所示。
Mybatis之Javassist字节码生成开源框架 - 图3
对应的静态的代理模式代码如下所示：

  1. package com.foo.proxy;
  3. /**
  4.  * 售票服务接口实现类，车站
  5.  * @author louluan
  6.  */
  7. public class Station implements TicketService {
  9.     @Override
  10.     public void sellTicket() {
  11.         System.out.println("\n\t售票.....\n");
  12.     }
  14.     @Override
  15.     public void inquire() {
  16.         System.out.println("\n\t问询。。。。\n");
  17.     }
  19.     @Override
  20.     public void withdraw() {
  21.         System.out.println("\n\t退票......\n");
  22.     }
  24. }
  1. package com.foo.proxy;
  2. /**
  3.  * 售票服务接口 
  4.  * @author louluan
  5.  */
  6. public interface TicketService {
  8.     //售票
  9.     public void sellTicket();
  11.     //问询
  12.     public void inquire();
  14.     //退票
  15.     public void withdraw();
  17. }
  1. package com.foo.proxy;
  3. /**
  4.  * 车票代售点
  5.  * @author louluan
  6.  *
  7.  */
  8. public class StationProxy implements TicketService {
  10.     private Station station;
  12.     public StationProxy(Station station){
  13.         this.station = station;
  14.     }
  16.     @Override
  17.     public void sellTicket() {
  19.         // 1.做真正业务前，提示信息
  20.         this.showAlertInfo("××××您正在使用车票代售点进行购票，每张票将会收取5元手续费！××××");
  21.         // 2.调用真实业务逻辑
  22.         station.sellTicket();
  23.         // 3.后处理
  24.         this.takeHandlingFee();
  25.         this.showAlertInfo("××××欢迎您的光临，再见！××××\n");
  27.     }
  29.     @Override
  30.     public void inquire() {
  31.         // 1做真正业务前，提示信息
  32.         this.showAlertInfo("××××欢迎光临本代售点，问询服务不会收取任何费用，本问询信息仅供参考，具体信息以车站真实数据为准！××××");
  33.         // 2.调用真实逻辑
  34.         station.inquire();
  35.         // 3。后处理
  36.         this.showAlertInfo("××××欢迎您的光临，再见！××××\n");
  37.     }
  39.     @Override
  40.     public void withdraw() {
  41.         // 1。真正业务前处理
  42.         this.showAlertInfo("××××欢迎光临本代售点，退票除了扣除票额的20%外，本代理处额外加收2元手续费！××××");
  43.         // 2.调用真正业务逻辑
  44.         station.withdraw();
  45.         // 3.后处理
  46.         this.takeHandlingFee();
  48.     }
  50.     /*
  51.      * 展示额外信息
  52.      */
  53.     private void showAlertInfo(String info) {
  54.         System.out.println(info);
  55.     }
  57.     /*
  58.      * 收取手续费
  59.      */
  60.     private void takeHandlingFee() {
  61.         System.out.println("收取手续费，打印发票。。。。。\n");
  62.     }
  64. }

由于我们现在不希望静态地有StationProxy类存在，希望在代码中，动态生成器二进制代码，加载进来。为此，使用Javassist开源框架，在代码中动态地生成StationProxy的字节码：

  1. package com.foo.proxy;
  4. import java.lang.reflect.Constructor;
  6. import javassist.*;
  7. public class Test {
  9.     public static void main(String[] args) throws Exception {
  10.        createProxy();
  11.     }
  13.     /*
  14.      * 手动创建字节码
  15.      */
  16.     private static void createProxy() throws Exception
  17.     {
  18.         ClassPool pool = ClassPool.getDefault();
  20.         CtClass cc = pool.makeClass("com.foo.proxy.StationProxy");
  22.         //设置接口
  23.         CtClass interface1 = pool.get("com.foo.proxy.TicketService");
  24.         cc.setInterfaces(new CtClass[]{interface1});
  26.         //设置Field
  27.         CtField field = CtField.make("private com.foo.proxy.Station station;", cc);
  29.         cc.addField(field);
  31.         CtClass stationClass = pool.get("com.foo.proxy.Station");
  32.         CtClass[] arrays = new CtClass[]{stationClass};
  33.         CtConstructor ctc = CtNewConstructor.make(arrays,null,CtNewConstructor.PASS_NONE,null,null, cc);
  34.         //设置构造函数内部信息
  35.         ctc.setBody("{this.station=$1;}");
  36.         cc.addConstructor(ctc);
  38.         //创建收取手续 takeHandlingFee方法
  39.         CtMethod takeHandlingFee = CtMethod.make("private void takeHandlingFee() {}", cc);
  40.         takeHandlingFee.setBody("System.out.println(\"收取手续费，打印发票。。。。。\");");
  41.         cc.addMethod(takeHandlingFee);
  43.         //创建showAlertInfo 方法
  44.         CtMethod showInfo = CtMethod.make("private void showAlertInfo(String info) {}", cc);
  45.         showInfo.setBody("System.out.println($1);");
  46.         cc.addMethod(showInfo);
  48.         //sellTicket
  49.         CtMethod sellTicket = CtMethod.make("public void sellTicket(){}", cc);
  50.         sellTicket.setBody("{this.showAlertInfo(\"××××您正在使用车票代售点进行购票，每张票将会收取5元手续费！××××\");"
  51.                 + "station.sellTicket();"
  52.                 + "this.takeHandlingFee();"
  53.                 + "this.showAlertInfo(\"××××欢迎您的光临，再见！××××\");}");
  54.         cc.addMethod(sellTicket);
  56.         //添加inquire方法
  57.         CtMethod inquire = CtMethod.make("public void inquire() {}", cc);
  58.         inquire.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，问询服务不会收取任何费用，本问询信息仅供参考，具体信息以车站真实数据为准！××××\");"
  59.         + "station.inquire();"
  60.         + "this.showAlertInfo(\"××××欢迎您的光临，再见！××××\");}"
  61.         );
  62.         cc.addMethod(inquire);
  64.         //添加widthraw方法
  65.         CtMethod withdraw = CtMethod.make("public void withdraw() {}", cc);
  66.         withdraw.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，退票除了扣除票额的20%外，本代理处额外加收2元手续费！××××\");"
  67.                 + "station.withdraw();"
  68.                 + "this.takeHandlingFee();}"
  69.                 );
  70.         cc.addMethod(withdraw);
  72.         //获取动态生成的class
  73.         Class c = cc.toClass();
  74.         //获取构造器
  75.         Constructor constructor= c.getConstructor(Station.class);
  76.         //通过构造器实例化
  77.         TicketService o = (TicketService)constructor.newInstance(new Station());
  78.         o.inquire();
  80.         cc.writeFile("D://test");
  81.     }
  83. }

上述代码执行过后，会产生StationProxy的字节码，并且用生成字节码加载如内存创建对象，调用inquire()方法，会得到以下结果：
Mybatis之Javassist字节码生成开源框架 - 图4
通过上面动态生成的代码，我们发现，其实现相当地麻烦在创造的过程中，含有太多的业务代码。我们使用上述创建Proxy代理类的方式的初衷是减少系统代码的冗杂度，但是上述做法却增加了在动态创建代理类过程中的复杂度：手动地创建了太多的业务代码，并且封装性也不够，完全不具有可拓展性和通用性。如果某个代理类的一些业务逻辑非常复杂，上述的动态创建代理的方式是非常不可取的！


版权声明：本文为CSDN博主「亦山」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/luanlouis/article/details/24589193