(转载)JAVA动态编译--字节代码的操纵

在通常的Java应用开发过程当中，开发人员使用Java的方式比较简单。打开惯用的IDE，编写Java源代码，再利用IDE提供的功能直接运行Java 程序就能够了。这种开发模式背后的过程是：开发人员编写的是Java源代码文件（.java），IDE会负责调用Java的编译器把Java源代码编译成平台无关的字节代码（byte code），以类文件的形式保存在磁盘上（.class）。Java虚拟机（JVM）会负责把Java字节代码加载并执行。Java经过这种方式来实现其“编写一次，处处运行（Write once, run anywhere）” 的目标。Java类文件中包含的字节代码能够被不一样平台上的JVM所使用。Java字节代码不只能够以文件形式存在于磁盘上，也能够经过网络方式来下载，还能够只存在于内存中。JVM中的类加载器会负责从包含字节代码的字节数组（byte[]）中定义出Java类。在某些状况下，可能会须要动态的生成 Java字节代码，或是对已有的Java字节代码进行修改。这个时候就须要用到本文中将要介绍的相关技术。首先介绍一下如何动态编译Java源文件。

动态编译Java源文件

在通常状况下，开发人员都是在程序运行以前就编写完成了所有的Java源代码而且成功编译。对有些应用来讲，Java源代码的内容在运行时刻才能肯定。这个时候就须要动态编译源代码来生成Java字节代码，再由JVM来加载执行。典型的场景是不少算法竞赛的在线评测系统（如PKU JudgeOnline），容许用户上传Java代码，由系统在后台编译、运行并进行断定。在动态编译Java源文件时，使用的作法是直接在程序中调用Java编译器。

JSR 199 引入了Java编译器API。若是使用JDK 6的话，能够经过此API来动态编译Java代码。好比下面的代码用来动态编译最简单的Hello World类。该Java类的代码是保存在一个字符串中的。

public class CompilerTest {
   public static void main(String[] args) throws Exception {      
      String source = "public class Main { public static void main(String[] args) {System.out.println(\"Hello World!\");} }";
      JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
      StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
      StringSourceJavaObject sourceObject = new CompilerTest.StringSourceJavaObject("Main", source);
      Iterable< extends JavaFileObject> fileObjects = Arrays.asList(sourceObject);
      CompilationTask task = compiler.getTask(null, fileManager, null, null, null, fileObjects);
      boolean result = task.call();
      if (result) {
         System.out.println("编译成功。");
      }
   }

   static class StringSourceJavaObject extends SimpleJavaFileObject {

      private String content = null;
      public StringSourceJavaObject(String name, String content) ??throws URISyntaxException {
         super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
         this.content = content;
      }

      public CharSequence getCharContent(boolean ignoreEncodingErrors) ??throws IOException {
         return content;
      }
   }
}

若是不能使用JDK 6提供的Java编译器API的话，可使用JDK中的工具类com.sun.tools.javac.Main，不过该工具类只能编译存放在磁盘上的文件，相似于直接使用javac命令。

另一个可用的工具是Eclipse JDT Core提供的编译器。这是Eclipse Java开发环境使用的增量式Java编译器，支持运行和调试有错误的代码。该编译器也能够单独使用。Play框架在内部使用了JDT的编译器来动态编译Java源代码。在开发模式下，Play框架会按期扫描项目中的Java源代码文件，一旦发现有修改，会自动编译 Java源代码。所以在修改代码以后，刷新页面就能够看到变化。使用这些动态编译的方式的时候，须要确保JDK中的tools.jar在应用的 CLASSPATH中。

下面介绍一个例子，是关于如何在Java里面作四则运算，好比求出来(3+4)*7-10的值。通常的作法是分析输入的运算表达式，本身来模拟计算过程。考虑到括号的存在和运算符的优先级等问题，这样的计算过程会比较复杂，并且容易出错。另一种作法是能够用JSR 223引入的脚本语言支持，直接把输入的表达式当作JavaScript或是JavaFX脚原本执行，获得结果。下面的代码使用的作法是动态生成Java源代码并编译，接着加载Java类来执行并获取结果。这种作法彻底使用Java来实现。

 1 private static double calculate(String expr) throws CalculationException  {
 2    String className = "CalculatorMain";
 3    String methodName = "calculate";
 4    String source = "public class " + className 
 5       + " { public static double " + methodName + "() { return " + expr + "; } }";
 6       //省略动态编译Java源代码的相关代码，参见上一节
 7    boolean result = task.call();
 8    if (result) {
 9       ClassLoader loader = Calculator.class.getClassLoader(); 
10       try {            
11          Class<?> clazz = loader.loadClass(className);
12          Method method = clazz.getMethod(methodName, new Class<?>[] {});
13          Object value = method.invoke(null, new Object[] {});
14          return (Double) value;
15       } catch (Exception e) {
16          throw new CalculationException("内部错误。");        
17       }    
18    } else {
19       throw new CalculationException("错误的表达式。");    
20    }
21 }

View Code

 上面的代码给出了使用动态生成的Java字节代码的基本模式，即经过类加载器来加载字节代码，建立Java类的对象的实例，再经过Java反射API来调用对象中的方法。

Java字节代码加强

Java 字节代码加强指的是在Java字节代码生成以后，对其进行修改，加强其功能。这种作法至关于对应用程序的二进制文件进行修改。在不少Java框架中均可以见到这种实现方式。Java字节代码加强一般与Java源文件中的注解（annotation）一块使用。注解在Java源代码中声明了须要加强的行为及相关的元数据，由框架在运行时刻完成对字节代码的加强。Java字节代码加强应用的场景比较多，通常都集中在减小冗余代码和对开发人员屏蔽底层的实现细节上。用过JavaBeans的人可能对其中那些必须添加的getter/setter方法感到很繁琐，而且难以维护。而经过字节代码加强，开发人员只须要声明Bean中的属性便可，getter/setter方法能够经过修改字节代码来自动添加。用过JPA的人，在调试程序的时候，会发现实体类中被添加了一些额外的 域和方法。这些域和方法是在运行时刻由JPA的实现动态添加的。字节代码加强在面向方面编程（AOP）的一些实现中也有使用。

在讨论如何进行字节代码加强以前，首先介绍一下表示一个Java类或接口的字节代码的组织形式。

类文件 {
   0xCAFEBABE，小版本号，大版本号，常量池大小，常量池数组，
   访问控制标记，当前类信息，父类信息，实现的接口个数，实现的接口信息数组，域个数，
   域信息数组，方法个数，方法信息数组，属性个数，属性信息数组
}

如上所示，一个类或接口的字节代码使用的是一种松散的组织结构，其中所包含的内容依次排列。对于可能包含多个条目的内容，如所实现的接口、域、方法和属性等，是以数组来表示的。而在数组以前的是该数组中条目的个数。不一样的内容类型，有其不一样的内部结构。对于开发人员来讲，直接操纵包含字节代码的字节数组的话，开发效率比较低，并且容易出错。已经有很多的开源库能够对字节代码进行修改或是从头开始建立新的Java类的字节代码内容。这些类库包括ASM、cglib、serp和BCEL等。使用这些类库能够在必定程度上下降加强字节代码的复杂度。好比考虑下面一个简单的需求，在一个Java类的全部方法执行以前输出相应的日志。熟悉AOP的人都知道，能够用一个前加强（before advice）来解决这个问题。若是使用ASM的话，相关的代码以下：

 1 ClassReader cr = new ClassReader(is);
 2 ClassNode cn = new ClassNode();
 3 cr.accept(cn, 0);
 4 for (Object object : cn.methods) {    
 5    MethodNode mn = (MethodNode) object;   
 6    if ("<init>".equals(mn.name) || "<clinit>".equals(mn.name)) {        
 7       continue;    
 8    }    
 9    InsnList insns = mn.instructions;    
10    InsnList il = new InsnList();   
11    il.add(new FieldInsnNode(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"));    
12    il.add(new LdcInsnNode("Enter method -> " + mn.name));   
13    il.add(new MethodInsnNode(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"));    
14    insns.insert(il);  mn.maxStack += 3;
15 }
16 ClassWriter cw = new ClassWriter(0);
17 cn.accept(cw);
18 byte[] b = cw.toByteArray();

View Code

从ClassWriter就能够获取到包含加强以后的字节代码的字节数组，能够把字节代码写回磁盘或是由类加载器直接使用。上述示例中，加强部分的逻辑比较简单，只是遍历Java类中的全部方法并添加对System.out.println方法的调用。在字节代码中，Java方法体是由一系列的指令组成的。而要作的是生成调用System.out.println方法的指令，并把这些指令插入到指令集合的最前面。ASM对这些指令作了抽象，不过熟悉所有的指令比较困难。ASM提供了一个工具类ASMifierClassVisitor，能够打印出Java类的字节代码的结构信息。当须要加强某个类的时候，能够先在源代码上作出修改，再经过此工具类来比较修改先后的字节代码的差别，从而肯定该如何编写加强的代码。

对类文件进行加强的时机是须要在Java源代码编译以后，在JVM执行以前。比较常见的作法有：

• 由IDE在完成编译操做以后执行。如Google App Engine的Eclipse插件会在编译以后运行DataNucleus来对实体类进行加强。
• 在构建过程当中完成，好比经过Ant或Maven来执行相关的操做。
• 实现本身的Java类加载器。当获取到Java类的字节代码以后，先进行加强处理，再从修改过的字节代码中定义出Java类。
• 经过JDK 5引入的java.lang.instrument包来完成。

java.lang.instrument

因为存在着大量对Java字节代码进行修改的需求，JDK 5引入了java.lang.instrument包并在JDK 6中获得了进一步的加强。基本的思路是在JVM启动的时候添加一些代理（agent）。每一个代理是一个jar包，其清单（manifest）文件中会指定一个代理类。这个类会包含一个premain方法。JVM在启动的时候会首先执行代理类的premain方法，再执行Java程序自己的main方法。在 premain方法中就能够对程序自己的字节代码进行修改。JDK 6中还容许在JVM启动以后动态添加代理。java.lang.instrument包支持两种修改的场景，一种是重定义一个Java类，即彻底替换一个 Java类的字节代码；另一种是转换已有的Java类，至关于前面提到的类字节代码加强。仍是之前面提到的输出方法执行日志的场景为例，首先须要实现java.lang.instrument.ClassFileTransformer接口来完成对已有Java类的转换。

 1 static class MethodEntryTransformer implements ClassFileTransformer {
 2    public byte[] transform(ClassLoader loader, String className,
 3      Class<?> classBeingRedefined, ?ProtectionDomain protectionDomain, byte[] classfileBuffer) 
 4      throws  IllegalClassFormatException {
 5         try {
 6            ClassReader cr = new ClassReader(classfileBuffer);
 7            ClassNode cn = new ClassNode();            
 8            //省略使用ASM进行字节代码转换的代码            
 9            ClassWriter cw = new ClassWriter(0);
10            cn.accept(cw); 
11            return cw.toByteArray();       
12         } catch (Exception e){            
13            return null;
14         }
15    }
16 }

View Code

 

有了这个转换类以后，就能够在代理的premain方法中使用它。

public static void premain(String args, Instrumentation inst) {    
   inst.addTransformer(new MethodEntryTransformer());
}

 

把该代理类打成一个jar包，并在jar包的清单文件中经过Premain-Class声明代理类的名称。运行Java程序的时候，添加JVM启动参数-javaagent:myagent.jar。这样的话，JVM会在加载Java类的字节代码以前，完成相关的转换操做。

总结

操纵Java字节代码是一件颇有趣的事情。经过它，能够很容易的对二进制分发的Java程序进行修改，很是适合于性能分析、调试跟踪和日志记录等任务。另一个很是重要的做用是把开发人员从繁琐的Java语法中解放出来。开发人员应该只须要负责编写与业务逻辑相关的重要代码。对于那些只是由于语法要求而添加的，或是模式固定的代码，彻底能够将其字节代码动态生成出来。字节代码加强和源代码生成是不一样的概念。源代码生成以后，就已经成为了程序的一部分，开发人员须要去维护它：要么手工修改生成出来的源代码，要么从新生成。而字节代码的加强过程，对于开发人员是彻底透明的。妥善使用Java字节代码的操纵技术，能够更好的解决某一类开发问题。

参考资料

• Java字节代码格式
• Java 6.0 Compiler API
• 深刻探讨Java类加载器