使用javassist动态注入代码-OO-Java

官方主页：http://www.csg.is.titech.ac.jp/~chiba/javassist/

Javassist ，Cglib 等是一些代码增强工具，在运行时刻进行Java字节码增强，虽然速度上稍微慢一点点，但是带来的是代码的简洁，今天用Javassist进行代码增强。

代码：

TestBean.java

 

1. package  javassist.sample;
3. public   abstract   class  TestBean {
5.      public  String field;
7.      public   abstract  String getM();
9.      public   abstract   void  setF(String f);
11.      public  String getF() {
12.          return   this .field;
13.     }
14. }

TestByteCode.java

 

1. package  javassist.sample;
3. import  javassist.ClassPool;
4. import  javassist.CtClass;
5. import  javassist.CtConstructor;
6. import  javassist.CtMethod;
8. public   class  TestByteCode {
10.      public   static   void  main(String[] args)  throws  Exception {
11.         
12.         ClassPool pool = ClassPool.getDefault();
13.         CtClass pt = pool.makeClass( "asdf" , pool.get( "javassist.sample.TestBean" ));
15.         CtMethod method1 =  new  CtMethod(pool.get( "java.lang.String" ),  "getM" ,  null , pt);
16.         method1.setBody( "{return \"你好\";}" );
17.         pt.addMethod(method1);
19.         CtConstructor cc =  new  CtConstructor( null , pt);
20.         cc.setBody( "this.field=\"why?\";" );
21.         pt.addConstructor(cc);
23.         CtMethod method2 =  new  CtMethod(CtClass.voidType,  "setF" ,
24.                  new  CtClass[] { pool.get( "java.lang.String" ) }, pt);
25.         method2.setBody( "{this.field=$1;}" );
26.         pt.addMethod(method2);
28.         Class<?> c = pt.toClass();
29.         TestBean bean = (TestBean) c.newInstance();
31.         System.out.println(bean.getM());
32.         System.out.println(bean.getF());
33.         bean.setF( "setf" );
34.         System.out.println(bean.getF());
35.     }
36. }

输出为：

你好

why?

setf

可以看到实现了动态的构造，动态实现抽象函数。在进行代码自动化项目中，能够使用字节码增强将大大提高代码的质量，和减少代码的数量。

 

再看一个例子：

A.java

 

1. package  javassist.demo;
3. public   class  A {
5.      public   void  method() {
6.          for  ( int  i =  0 ; i <  1000000 ; i++) {
7.         }

 

关 于java字节码的处理，目前有很多工具，如bcel，asm。不过这些都需要直接跟虚拟机指令打交道。如果你不想了解虚拟机指令，可以采用 javassist。javassist是jboss的一个子项目，其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机 指令，就能动态改变类的结构，或者动态生成类。
    下面通过一个简单的例子，通过javassist来实现如何动态注入代码。
    假设，存在类A,如下：

java 代码

 

1. public   class  A {  
2.     public   void  method() {  
3.         for  ( int  i =  0 ; i <  1000000 ; i++) {  
4.         }  
5.         System.out.println("method1" );  
6.     }  
7. }  

测试类B如下：

java 代码

 

1. public   class  B {  
2.     public   static   void  main(String[] args) {  
3.         A a = new  A();  
4.         a.method();     
5.     }  
6. }  

现在想统计一下method的执行时间，
默认的实现是修改method：

 

java 代码

 

1. public   void  method() {  
2.         long  start = System.currentTimeMillis();  
3.         for  ( int  i =  0 ; i <  1000000 ; i++) {  
4.         }  
5.         System.out.println("method1" );  
6.         long  end = System.currentTimeMillis();  
7.         System.out.println(end - start);  
8.     }  

如果A的方法很多，统计方法的执行时间的代码就会相应的增加。为了减少工作量，通过动态注入代码的形式来实现。
修改B的main方法：

 

java 代码

 

1. public   static   void  main(String[] args)  throws  Exception {  
2.     //用于取得字节码类，必须在当前的classpath中，使用全称   
3.       CtClass ctClass = ClassPool.getDefault().get("org.esoft.A" );  
4.        //需要修改的方法名称   
5.       String mname = "method" ;         
6.       CtMethod mold = ctClass.getDeclaredMethod(mname);  
7.        //修改原有的方法名称   
8.       String nname = mname + "$impl" ;  
9.       mold.setName(nname);  
10.        //创建新的方法，复制原来的方法   
11.       CtMethod mnew = CtNewMethod.copy(mold, mname, ctClass, null );  
12.        //主要的注入代码   
13.       StringBuffer body = new  StringBuffer();  
14.       body.append("{\nlong start = System.currentTimeMillis();\n" );  
15.       //调用原有代码，类似于method();($$)表示所有的参数   
16.       body.append(nname + "($$);\n" );  
17.       body.append("System.out.println(\"Call to method "   
18.                   + mname  
19.                   + " took \" +\n (System.currentTimeMillis()-start) + "   
20.                   + "\" ms.\");\n" );  
21.       
22.       body.append("}" );  
23.        //替换新方法   
24.       mnew.setBody(body.toString());  
25.        //增加新方法   
26.       ctClass.addMethod(mnew);  
27.       //类已经更改，注意不能使用A a=new A();，因为在同一个classloader中，不允许装载同一个类两次   
28.       A a=(A)ctClass.toClass().newInstance();  
29.       a.method();  
30.   }  

这只是简单的一个应用。javassist还提供了很多的功能，用于更改类结构。有兴趣的可以参考相关文档