[关闭]
@dawn 2016-03-31T08:00:18.000000Z 字数 7109 阅读 314

javassist

未分类

1、为什么要用这个

很多的时候，我们需要根据注解、配置文件或者其它的方式来运行不同的代码，大多数时候我们可能会使用条件判断（if..else，swith..case），或者java中的反射来实现。

这样方式有一个很大的问题是我们需要在设计之初就考虑到所有的情况，并对外提供统一的接口，第三方实现这些接口即可。

但是这并不是一个一劳永逸的方法，在设计一个框架时，我们考虑的指标往往是非常多的，

还有很多很多

2、有哪些项目在用

像spring的注解，使用了javassist与cglib，fastJson的序列化与反序列化，为了达到更快的速度，同样使用了javassist

3、关于javassist

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

常用的一些类
Classes.png-48.9kB

例如CtClass、CtMember、CtMethod、CtField，可以简单的理解为这是对相应的类、成员封装，提供了一系列基于源码级别的API。
基于javassist开发，不需要了解字节码的一些知识，而且其封装的一些工具类可以简单实现一些高级功能。

参考:
javassist 学习笔记
性能对比

原理

Java编译器编译好Java文件之后，产生.class 文件在磁盘中。这种class文件是二进制文件，内容是只有JVM虚拟机能够识别的机器码。JVM虚拟机读取字节码文件，取出二进制数据，加载到内存中，解析.class 文件内的信息，生成对应的 Class对象。

4、例子

Javassist的使用很简单，首先获取到class定义的容器ClassPool，通过它获取已经编译好的类(Compile time class)，并给这个类设置一个父类，而writeFile讲这个类的定义从新写到磁盘，以便后面使用。

简单的例子

  1. public class E1 {
  3.     public static void main(String[] args) throws IOException, CannotCompileException, NotFoundException, IllegalAccessException, InstantiationException {
  4.         ClassPool pool = ClassPool.getDefault();
  5.         CtClass cc = pool.get("com.yodo1.example.T1");
  7.         CtMethod cm = cc.getDeclaredMethod("print");
  8.         cm.insertBefore("{System.out.println(\"call T1.print\");}");
  10.         //cc.writeFile();
  12.         T1 t1 = (T1) cc.toClass().newInstance();
  13.         t1.print();
  15.         T1 t2 = new T1();
  16.         t2.print();
  17.     }
  19. }
  21. class T1{
  22.     void print(){
  23.         System.out.println("t1 print");
  24.     }
  25. }
  28. 这个例子修改了T1的print方法，最终的输出如下
  30. call T1.print
  31. t1 print
  32. call T1.print
  33. t1 print

一个更加复杂的例子

  1. public class E2 {
  4.     public static void main(String[] args) throws ClassNotFoundException, CannotCompileException, InstantiationException, NotFoundException, IllegalAccessException {
  6.         Handler h = getHandler();
  7.         h.handle("login");
  8.         h.handle("exit");
  9.         h.handle("reg");
  10.         h.handle("doSomething");
  12.     }
  14.     public static Handler getHandler() throws NotFoundException, ClassNotFoundException, CannotCompileException, IllegalAccessException, InstantiationException {
  16.         String s1 = "this is s1";
  18.         ClassPool pool = ClassPool.getDefault();
  19.         CtClass ccBean1 = pool.get("com.yodo1.example.Bean1");
  20.         CtClass ccHandler = pool.get("com.yodo1.example.Handler");
  22.         ccBean1.addInterface(ccHandler);
  24.         StringBuilder invokerStr = new StringBuilder("public void handle(String optString) {\n");
  26.         CtMethod[] ctms = ccBean1.getDeclaredMethods();
  27.         for (CtMethod cm : ctms) {
  28.             if (cm.getAnnotation(Opt.class) != null) {
  29.                 String methodName = cm.getName();
  30.                 invokerStr.append("if(optString.equals(\"");
  31.                 invokerStr.append(methodName);
  32.                 invokerStr.append("\")){");
  33.                 invokerStr.append(methodName);
  34.                 invokerStr.append("(); return;}\n");
  35.             }
  36.         }
  38.         invokerStr.append("System.out.println(\"method: \"+ optString + \"() not exist\");\n}");
  39.         System.out.println("code desc...");
  40.         System.out.println(invokerStr);
  41.         System.out.println();
  42.         System.out.println();
  44.         CtMethod invokeMethod = CtMethod.make(invokerStr.toString(), ccBean1);
  45.         invokeMethod.setModifiers(Modifier.PUBLIC);
  46.         ccBean1.addMethod(invokeMethod);
  48.         return (Handler) ccBean1.toClass().newInstance();
  49.     }
  50. }
  51. //---------
  53. @Target({ElementType.METHOD})
  54. @Retention(RetentionPolicy.RUNTIME)
  55. @Documented
  56. @interface Opt {
  57. }
  58. //---------
  60. interface Handler {
  62.     void handle(String optString);
  63. }
  65. //---------
  67. class Bean1 {
  70.     @Opt
  71.     public void login() {
  72.         System.out.println("this is login");
  73.     }
  75.     @Opt
  76.     public void reg() {
  77.         System.out.println("this is reg");
  78.     }
  80.     @Opt
  81.     public void exit() {
  82.         System.out.println("this is exit");
  83.     }
  84. }

最终的输出如下

  1. code desc...
  2. public void handle(String optString) {
  3. if(optString.equals("login")){login(); return;}
  4. if(optString.equals("reg")){reg(); return;}
  5. if(optString.equals("exit")){exit(); return;}
  6. System.out.println("method: "+ optString + "() not exist");
  7. }
  10. this is login
  11. this is exit
  12. this is reg
  13. method: doSomething() not exist
关于泛型，在jvm中是没有泛型概念的，所有的泛型对象最后都会被转成普通对象，所有，javassit是不支持泛型的。

5、与其它的实现方式比较

java字节码操作库：BCEL、cglib、javassit、ObjectWeb ASM、SERP、Package gnu.bytecode 、Cojen、Trove Class File API、Jiapi 、Classfile Reader & Writer 、JBET 、Retroweaver、Jen、Soot、Jdec、JReloader

我们常见的有BCEL、cglib，有的库是直接去操作字节码，在实际的使用中难度稍大，而BCEL、cglib的封装程度与javassit差不多，网上找的两个例子

ObjectWeb ASM

  1. import  java.io.FileOutputStream;  
  2. import  java.io.PrintStream;  
  4. import  org.objectweb.asm.ClassWriter;  
  5. import  org.objectweb.asm.MethodVisitor;  
  6. import  org.objectweb.asm.Opcodes;  
  7. import  org.objectweb.asm.Type;  
  8. import  org.objectweb.asm.commons.GeneratorAdapter;  
  9. import  org.objectweb.asm.commons.Method;  
  11. public   class  Helloworld  extends  ClassLoader  implements  Opcodes {  
  13.   public   static   void  main( final  String args[])  throws  Exception {  
  15.     // creates a ClassWriter for the Example public class,   
  16.     // which inherits from Object   
  18.     ClassWriter cw = new  ClassWriter( 0 );  
  19.     cw.visit(V1_1, ACC_PUBLIC, "Example" ,  null ,  "java/lang/Object" ,  null );  
  20.     MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "<init>" ,  "()V" ,  null ,  
  21.         null );  
  22.     mw.visitVarInsn(ALOAD, 0 );  
  23.     mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object" ,  "<init>" ,  "()V" );  
  24.     mw.visitInsn(RETURN);  
  25.     mw.visitMaxs(1 ,  1 );  
  26.     mw.visitEnd();  
  27.     mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main" ,  
  28.         "([Ljava/lang/String;)V" ,  null ,  null );  
  29.     mw.visitFieldInsn(GETSTATIC, "java/lang/System" ,  "out" ,  
  30.         "Ljava/io/PrintStream;" );  
  31.     mw.visitLdcInsn("Hello world!" );  
  32.     mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream" ,  "println" ,  
  33.         "(Ljava/lang/String;)V" );  
  34.     mw.visitInsn(RETURN);  
  35.     mw.visitMaxs(2 ,  2 );  
  36.     mw.visitEnd();  
  37.     byte [] code = cw.toByteArray();  
  38.     FileOutputStream fos = new  FileOutputStream( "Example.class" );  
  39.     fos.write(code);  
  40.     fos.close();  
  41.     Helloworld loader = new  Helloworld();  
  42.     Class exampleClass = loader  
  43.         .defineClass("Example" , code,  0 , code.length);  
  44.     exampleClass.getMethods()[0 ].invoke( null ,  new  Object[] {  null  });  
  46.     // ------------------------------------------------------------------------   
  47.     // Same example with a GeneratorAdapter (more convenient but slower)   
  48.     // ------------------------------------------------------------------------   
  50.     cw = new  ClassWriter(ClassWriter.COMPUTE_MAXS);  
  51.     cw.visit(V1_1, ACC_PUBLIC, "Example" ,  null ,  "java/lang/Object" ,  null );  
  52.     Method m = Method.getMethod("void <init> ()" );  
  53.     GeneratorAdapter mg = new  GeneratorAdapter(ACC_PUBLIC, m,  null ,  null ,  
  54.         cw);  
  55.     mg.loadThis();  
  56.     mg.invokeConstructor(Type.getType(Object.class ), m);  
  57.     mg.returnValue();  
  58.     mg.endMethod();  
  59.     m = Method.getMethod("void main (String[])" );  
  60.     mg = new  GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m,  null ,  null , cw);  
  61.     mg.getStatic(Type.getType(System.class ),  "out" , Type  
  62.         .getType(PrintStream.class ));  
  63.     mg.push("Hello world!" );  
  64.     mg.invokeVirtual(Type.getType(PrintStream.class ), Method  
  65.         .getMethod("void println (String)" ));  
  66.     mg.returnValue();  
  67.     mg.endMethod();  
  68.     cw.visitEnd();  
  69.     code = cw.toByteArray();  
  70.     loader = new  Helloworld();  
  71.     exampleClass = loader.defineClass("Example" , code,  0 , code.length);  
  72.     exampleClass.getMethods()[0 ].invoke( null ,  new  Object[] {  null  });  
  73.   }  
  74. }

cglib

  1. public   class  MyClass {  
  2.   public   void  print() {  
  3.     System.out.println("I'm in MyClass.print!" );  
  4.   }  
  5. }  
  8. import  java.lang.reflect.Method;  
  9. import  net.sf.cglib.proxy.Enhancer;  
  10. import  net.sf.cglib.proxy.MethodInterceptor;  
  11. import  net.sf.cglib.proxy.MethodProxy;  
  13. public   class  Main {  
  15.   public   static   void  main(String[] args) {  
  17.     Enhancer enhancer = new  Enhancer();  
  18.     enhancer.setSuperclass(MyClass.class );  
  19.     enhancer.setCallback(new  MethodInterceptorImpl());  
  20.     MyClass my = (MyClass) enhancer.create();  
  21.     my.print();  
  22.   }  
  24.   private   static   class  MethodInterceptorImpl  implements  MethodInterceptor {  
  25.     public  Object intercept(Object obj, Method method, Object[] args,  
  26.         MethodProxy proxy) throws  Throwable {  
  27.       // log something   
  28.       System.out.println(method + " intercepted!" );  
  30.       proxy.invokeSuper(obj, args);  
  31.       return   null ;  
  32.     }  
  33.   }  
  34. }  
  37. 最后输出为
  38. public   void  MyClass.print() intercepted!  
  39. I'm in MyClass.print!
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注