利用javax.tools动态编译执行java代码

　　inkfish原创，请勿商业性质转载，转载请注明来源（http://blog.csdn.net/inkfish ）。

　　参考：使用 javax.tools 创建动态应用程序

　　javax.tools 包是一种添加到 Java SE 6 的标准 API，可以实现 Java 源代码编译，使您能够添加动态功能来扩展静态应用程序。本文将探查javax.tools包中提供的主要类，以Java表达式表示计算一个数值函数y=x*x+x。更多详情请参考《使用 javax.tools 创建动态应用程序》和javax.tools API docs 。

complier.CharSequenceCompiler源码：

package complier; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import javax.tools.DiagnosticCollector; import javax.tools.JavaCompiler; import javax.tools.JavaFileObject; import javax.tools.StandardLocation; import javax.tools.ToolProvider; import javax.tools.JavaCompiler.CompilationTask; /** * 编译{@link CharSequence}形式的源码，并实例化，返回一个实例。<br> * 用法示例（以编译MyInterface的一个实现类为例）： * * <pre> * MyInterface instance = null; * JavaStringCompiler<MyInterface> compiler = new JavaStringCompiler<MyInterface>(null, null); * try { * Class<MyInterface> newClass = compiler.compile("com.mypackage.NewClass", * stringContaininSourceForNewClass, new Class<?>[] { MyInterface.class }); * instance = newClass.newInstance(); * } catch (JavaStringCompilerException ex) { * ex.printStackTrace(); * } catch (IllegalAccessException ex) { * ex.printStackTrace(); * } * instance.someOperation(someArgs); * </pre> */ public class CharSequenceCompiler<T> { /** 真正使用的编译器 */ private final JavaCompiler compiler; private final ClassLoaderImpl classLoader; /** 保存编译器编译中的诊断信息 */ private DiagnosticCollector<JavaFileObject> diagnostics; private final FileManagerImpl javaFileManager; /** 编译参数 */ private final List<String> options; /** * 构造一个新的实例，该实例持有指定的classloader * * @param loader * 应用的{@link ClassLoader} * @param options * 编译器的编译参数，具体可参考javac编译参数 * @throws IllegalStateException * 如果java编译器不能正确载入则抛出异常 */ public CharSequenceCompiler(ClassLoader loader, Collection<String> options) { compiler = ToolProvider.getSystemJavaCompiler(); if (compiler == null) { throw new IllegalStateException("系统java编译器无法找到，请确认类路径中已经包含tools.jar（注：JDK 6中默认自带，JRE 6中默认不带）。"); } if (loader == null) { classLoader = new ClassLoaderImpl(this.getClass().getClassLoader()); } else { classLoader = new ClassLoaderImpl(loader); } this.options = new ArrayList<String>(); if (options != null) { this.options.addAll(options); } diagnostics = new DiagnosticCollector<JavaFileObject>(); javaFileManager = new FileManagerImpl(compiler.getStandardFileManager(diagnostics, null, Charset .forName(Utils.ENCODING)), classLoader); } /** * 编译多个Java类的源码 * * @param classes * key为类的完全限定名，value为对应的源码。 * @return 编译后的类 * @throws CharSequenceCompilerException */ public synchronized Map<String, Class<T>> compile(Map<String, CharSequence> classes) throws CharSequenceCompilerException { //准备待编译文件 List<JavaFileObject> sources = new ArrayList<JavaFileObject>(); for (Entry<String, CharSequence> entry : classes.entrySet()) { String qualifiedClassName = entry.getKey(); CharSequence javaSource = entry.getValue(); if (javaSource != null) { int dotPos = qualifiedClassName.lastIndexOf('.'); String className = dotPos == -1 ? qualifiedClassName : qualifiedClassName .substring(dotPos + 1); String packageName = dotPos == -1 ? "" : qualifiedClassName.substring(0, dotPos); JavaFileObjectImpl source = new JavaFileObjectImpl(className, javaSource); sources.add(source); javaFileManager.putFileForInput(StandardLocation.SOURCE_PATH, packageName, className + ".java", source); } } //编译代码 CompilationTask task = compiler.getTask(null, javaFileManager, diagnostics, options, null, sources); Boolean result = task.call(); //返回编译结果 if ((result == null) || !result.booleanValue()) { throw new CharSequenceCompilerException("Compilation failed.", classes.keySet(), diagnostics); } try { Map<String, Class<T>> compiled = new HashMap<String, Class<T>>(); for (String qualifiedClassName : classes.keySet()) { compiled.put(qualifiedClassName, loadClass(qualifiedClassName)); } return compiled; } catch (ClassNotFoundException ex) { throw new CharSequenceCompilerException(classes.keySet(), ex, diagnostics); } catch (IllegalArgumentException ex) { throw new CharSequenceCompilerException(classes.keySet(), ex, diagnostics); } catch (SecurityException ex) { throw new CharSequenceCompilerException(classes.keySet(), ex, diagnostics); } } /** * 编译一个Java类。 * * @param qualifiedClassName * 类的完全限定名。 * @param javaSource * 编译的java类完整的源码。 * @param types * 0或多个类，用以检验被编译的类能否转换成这些类中任何一个。 * @return 编译后的类 * @throws CharSequenceCompilerException * 如果类无法被编译则抛出异常。 * @throws ClassCastException * 如果编译后的类无法转换成types中的任何一种类型，则抛出异常。 */ public synchronized Class<T> compile(String qualifiedClassName, CharSequence javaSource, Class<?>... types) throws CharSequenceCompilerException, ClassCastException { diagnostics = new DiagnosticCollector<JavaFileObject>(); Map<String, CharSequence> classes = new HashMap<String, CharSequence>(1); classes.put(qualifiedClassName, javaSource); Map<String, Class<T>> compiled = compile(classes); Class<T> newClass = compiled.get(qualifiedClassName); for (Class<?> type : types) { if (!type.isAssignableFrom(newClass)) { throw new ClassCastException(type.getName()); } } return newClass; } /** 载入Java类。 */ @SuppressWarnings("unchecked") private Class<T> loadClass(final String qualifiedClassName) throws ClassNotFoundException { return (Class<T>) classLoader.loadClass(qualifiedClassName); } }

complier.CharSequenceCompilerException源码：

package complier; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.Set; import javax.tools.DiagnosticCollector; import javax.tools.JavaFileObject; @SuppressWarnings("serial") public class CharSequenceCompilerException extends Exception { /** 所有被编译的类的完整类名 */ private Set<String> classNames; transient private DiagnosticCollector<JavaFileObject> diagnostics; public CharSequenceCompilerException(Set<String> qualifiedClassNames, Throwable cause, DiagnosticCollector<JavaFileObject> diagnostics) { super(cause); setClassNames(qualifiedClassNames); setDiagnostics(diagnostics); } public CharSequenceCompilerException(String message, Set<String> qualifiedClassNames, DiagnosticCollector<JavaFileObject> diagnostics) { super(message); setClassNames(qualifiedClassNames); setDiagnostics(diagnostics); } public CharSequenceCompilerException(String message, Set<String> qualifiedClassNames, Throwable cause, DiagnosticCollector<JavaFileObject> diagnostics) { super(message, cause); setClassNames(qualifiedClassNames); setDiagnostics(diagnostics); } /** @return 返回编译出问题的类的全名称 */ public Collection<String> getClassNames() { return Collections.unmodifiableSet(classNames); } /** 得到异常的诊断信息 */ public DiagnosticCollector<JavaFileObject> getDiagnostics() { return diagnostics; } private void setClassNames(Set<String> qualifiedClassNames) { classNames = new HashSet<String>(qualifiedClassNames); } private void setDiagnostics(DiagnosticCollector<JavaFileObject> diagnostics) { this.diagnostics = diagnostics; } }

complier.ClassLoaderImpl源码：

package complier; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Map; import javax.tools.JavaFileObject; import org.apache.commons.io.IOUtils; /** {@link ClassLoader}的一个实现，它map类名和JavaFileObjectImpl的实例。本类在{@link CharSequenceCompiler}和{@link FileManagerImpl}中被使用。 */ final class ClassLoaderImpl extends ClassLoader { private final Map<String, JavaFileObjectImpl> classes = new HashMap<String, JavaFileObjectImpl>(); ClassLoaderImpl(final ClassLoader parentClassLoader) { super(parentClassLoader); } @Override public InputStream getResourceAsStream(final String name) { if (name.endsWith(".class")) { String qualifiedClassName = name.substring(0, name.length() - ".class".length()) .replace('/', '.'); JavaFileObjectImpl file = classes.get(qualifiedClassName); if (file != null) { try { return new ByteArrayInputStream(IOUtils.toByteArray(file.openInputStream())); } catch (IOException ex) { } } } return super.getResourceAsStream(name); } protected void add(final String qualifiedClassName, final JavaFileObjectImpl javaFile) { classes.put(qualifiedClassName, javaFile); } /** @return 返回不可变的Collection，含有所有持有的{@link JavaFileObject}对象 */ protected Collection<JavaFileObjectImpl> files() { return Collections.unmodifiableCollection(classes.values()); } @Override protected Class<?> findClass(final String qualifiedClassName) throws ClassNotFoundException { JavaFileObject file = classes.get(qualifiedClassName); if (file != null) { try { byte[] bytes = IOUtils.toByteArray(file.openInputStream()); return defineClass(qualifiedClassName, bytes, 0, bytes.length); } catch (IOException ex) { } } // Workaround in Java 6. see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6434149 try { Class<?> c = Class.forName(qualifiedClassName); return c; } catch (ClassNotFoundException nf) { } return super.findClass(qualifiedClassName); } @Override protected synchronized Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException { return super.loadClass(name, resolve); } }

complier.FileManagerImpl源码：

package complier; import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Set; import javax.tools.FileObject; import javax.tools.ForwardingJavaFileManager; import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; import javax.tools.StandardLocation; import javax.tools.JavaFileObject.Kind; /** * {@link JavaFileManager}的一个实例，用于管理Java源代码和byte code。<br> * 所有的源码以{@link CharSequence}的形式保存在内存中，byte code以byte数组形式存放在内存中。 */ final class FileManagerImpl extends ForwardingJavaFileManager<JavaFileManager> { private final ClassLoaderImpl classLoader; private final Map<URI, JavaFileObject> fileObjects = new HashMap<URI, JavaFileObject>(); FileManagerImpl(JavaFileManager fileManager, ClassLoaderImpl classLoader) { super(fileManager); this.classLoader = classLoader; } @Override public ClassLoader getClassLoader(JavaFileManager.Location location) { return classLoader; } @Override public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException { FileObject o = fileObjects.get(uri(location, packageName, relativeName)); if (o != null) { return o; } return super.getFileForInput(location, packageName, relativeName); } @Override public JavaFileObject getJavaFileForOutput(Location location, String qualifiedName, Kind kind, FileObject outputFile) throws IOException { JavaFileObjectImpl file = new JavaFileObjectImpl(qualifiedName, kind); classLoader.add(qualifiedName, file); return file; } @Override public String inferBinaryName(Location loc, JavaFileObject file) { String result; if (file instanceof JavaFileObjectImpl) { result = file.getName(); } else { result = super.inferBinaryName(loc, file); } return result; } @Override public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException { Iterable<JavaFileObject> result = super.list(location, packageName, kinds, recurse); ArrayList<JavaFileObject> files = new ArrayList<JavaFileObject>(); if ((location == StandardLocation.CLASS_PATH) && kinds.contains(JavaFileObject.Kind.CLASS)) { for (JavaFileObject file : fileObjects.values()) { if ((file.getKind() == Kind.CLASS) && file.getName().startsWith(packageName)) { files.add(file); } } files.addAll(classLoader.files()); } else if ((location == StandardLocation.SOURCE_PATH) && kinds.contains(JavaFileObject.Kind.SOURCE)) { for (JavaFileObject file : fileObjects.values()) { if ((file.getKind() == Kind.SOURCE) && file.getName().startsWith(packageName)) { files.add(file); } } } for (JavaFileObject file : result) { files.add(file); } return files; } void putFileForInput(StandardLocation location, String packageName, String relativeName, JavaFileObject file) { fileObjects.put(uri(location, packageName, relativeName), file); } private URI uri(Location location, String packageName, String relativeName) { return Utils.toURI(new StringBuilder(location.getName()).append('/').append(packageName).append('/') .append(relativeName).toString()); } }

complier.JavaFileObjectImpl源码：

package complier; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; import javax.tools.FileObject; import javax.tools.JavaFileObject; import javax.tools.SimpleJavaFileObject; /** * {@link FileObject}和{@link JavaFileObject}的一个实现，它能持有java源代码或编译后的class。这个类可以用于： * <ol> * <li>存放需要传递给编译器的源码，这时使用的是{@link JavaFileObjectImpl#JavaFileObjectImpl(String, CharSequence)}构造器。</li> * <li>存放编译器编译完的byte code，这是使用的是{@link JavaFileObjectImpl#JavaFileObjectImpl(String, JavaFileObject.Kind)}</li> * </ol> */ final class JavaFileObjectImpl extends SimpleJavaFileObject { /** 如果kind == CLASS, 存储byte code，可以通过{@link #openInputStream()}得到 */ private ByteArrayOutputStream byteCode; /** 如果kind == SOURCE, 存储源码 */ private final CharSequence source; /** * 创建持有源码的实例 * * @param baseName * the base name * @param source * the source code */ JavaFileObjectImpl(final String baseName, final CharSequence source) { super(Utils.toURI(baseName + ".java"), Kind.SOURCE); this.source = source; } /** * 创建持有二进制byte code的实例 * * @param name * the file name * @param kind * the kind of file */ JavaFileObjectImpl(final String name, final Kind kind) { super(Utils.toURI(name), kind); source = null; } @Override public CharSequence getCharContent(final boolean ignoreEncodingErrors) throws UnsupportedOperationException { if (source == null) { throw new UnsupportedOperationException("getCharContent()"); } return source; } @Override public InputStream openInputStream() { return new ByteArrayInputStream(byteCode.toByteArray()); } @Override public OutputStream openOutputStream() { return (byteCode = new ByteArrayOutputStream()); } @Override public Writer openWriter() throws IOException { return new OutputStreamWriter(openOutputStream(), Utils.ENCODING); } }

complier.Utils源码：

package complier; import java.net.URI; import java.net.URISyntaxException; import java.nio.charset.Charset; public abstract class Utils { public static final String ENCODING = Charset.defaultCharset().name(); /** 把String转换成URI，如果转换异常不抛出URISyntaxException，而直接抛出RuntimeException。 */ static URI toURI(String name) { try { return new URI(name); } catch (URISyntaxException e) { throw new RuntimeException(e); } } }

　　以上代码为complier包中所有类，它对外暴露的主要方法是：CharSequenceCompiler<T>.compile(String qualifiedClassName, CharSequence javaSource, Class<?>... types) throws CharSequenceCompilerException, ClassCastException，通过它来动态编译字符串形式表示的java源代码。除此之外，包中其他方类和方法尽量使用默认访问权限，以避免他人误用以及隐藏实现细节。

　　下面是测试package中的内容：

complier.test.Function源码：定义了一个接口，动态编译的所有类实现这个接口。

package complier.test; public interface Function { double doFunction(double x); }

complier.test.Function实现类的模板，方便类的生成。

package $packageName; import static java.lang.Math.*; public class $className implements complier.test.Function { @Override public double doFunction(double x){ return $expression; } }

complier.test.ExpressionCal源码：里面含有一个静态测试类ExpressionCal$Tester。

package complier.test; import java.io.IOException; import java.text.DecimalFormat; import java.util.Arrays; import java.util.Random; import javax.script.Bindings; import javax.script.Compilable; import javax.script.CompiledScript; import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script.ScriptException; import javax.script.SimpleBindings; import javax.tools.Diagnostic; import javax.tools.DiagnosticCollector; import javax.tools.JavaFileObject; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.exception.ExceptionUtils; import complier.CharSequenceCompiler; import complier.CharSequenceCompilerException; import complier.Utils; public class ExpressionCal { /** 包名前缀 */ private static final String PACKAGE_NAME = "javaxtools.compiler.test.runtime"; public static class Tester { public static void main(String[] args) throws ScriptException { //第一遍测试 test(); System.out.println("------Test Twice------/n"); test(); } public static void test() throws ScriptException { DecimalFormat df = new DecimalFormat("0.00"); int loop = 10 * 10000 - 1; String exp = "x*x+x"; double d = new Random().nextDouble() * 100; long start; //直接计算 start = System.nanoTime(); for (int i = 0; i < loop; i++) { @SuppressWarnings("unused") double a = d * d + d; } System.out.printf(exp.replace("x", df.format(d)) + "=%2.4f/n", d * d + d); System.out.printf("Time of direct cal %d loops: %10.2f微秒./n/n", loop + 1, (System.nanoTime() - start) / 1000d); //编译源码并计算 start = System.nanoTime(); Function func = new ExpressionCal().newFunction(exp); System.out.printf("Java src complain time: %10.2f微秒, /t", (System.nanoTime() - start) / 1000d); start = System.nanoTime(); for (int i = 0; i < loop; i++) { func.doFunction(d); } System.out.printf(exp.replace("x", df.format(d)) + "=%2.4f/n", func.doFunction(d)); System.out.printf("Complained source %d loops: %10.2f微秒./n/n", loop + 1, (System.nanoTime() - start) / 1000d); //内置Javascript计算 start = System.nanoTime(); ScriptEngine se = new ScriptEngineManager().getEngineByName("ECMAScript"); CompiledScript script = ((Compilable) se).compile("var x;" + exp); System.out.printf("JS complain time: %10.2f微秒, /t", (System.nanoTime() - start) / 1000d); start = System.nanoTime(); Bindings binding = new SimpleBindings(); for (int i = 0; i < loop; i++) { binding.put("x", d); script.eval(binding); } binding.put("x", d); System.out.printf(exp.replace("x", df.format(d)) + "=%2.4f/n", script.eval(binding)); System.out.printf("Javascript %d loops: %10.2f微秒./n", loop + 1, (System.nanoTime() - start) / 1000d); } } /** 类名后缀 */ private int classNameSuffix = 0; /** 随机数生成器，用于生成随机的包名和类名 */ private static final Random random = new Random(); /** 字符串形式的Java源文件内容 */ private String template; private static final String TEMPLATE_NAME = "Function.java.template"; private static final String TARGET_VERSION = "1.6"; private final CharSequenceCompiler<Function> compiler = new CharSequenceCompiler<Function>(getClass() .getClassLoader(), Arrays.asList(new String[] { "-target", TARGET_VERSION, "-encoding", Utils.ENCODING })); public Function newFunction(String expr) { StringBuilder errStr = new StringBuilder(); Function result = null; try { //生成唯一的包名和类名 final String packageName = PACKAGE_NAME + digits(); final String className = "C_" + (classNameSuffix++) + digits(); final String qName = packageName + '.' + className; //生成类的源码 final String source = fillTemplate(packageName, className, expr); //编译源码 Class<Function> compiledFunction = compiler.compile(qName, source, new Class<?>[] { Function.class }); result = compiledFunction.newInstance(); } catch (CharSequenceCompilerException ex) { errStr.append(log(ex.getDiagnostics())); ex.printStackTrace(); } catch (InstantiationException ex) { errStr.append(ExceptionUtils.getFullStackTrace(ex)).append("/n"); ex.printStackTrace(); } catch (IllegalAccessException ex) { errStr.append(ExceptionUtils.getFullStackTrace(ex)).append("/n"); ex.printStackTrace(); } catch (IOException ex) { errStr.append(ExceptionUtils.getFullStackTrace(ex)).append("/n"); ex.printStackTrace(); } if (errStr.toString().trim().length() > 0) { System.err.println(errStr.toString()); } return result; } /** @return 返回以'_'开头的随机16进制字符串 */ private String digits() { return '_' + Long.toHexString(random.nextLong()); } /** * 生成字符串形式的java源文件内容 * * @param packageName * 包名 * @param className * 类名 * @param expression * 表达式 * @return 字符串形式的java源文件内容 * @throws IOException */ private String fillTemplate(String packageName, String className, String expression) throws IOException { if (template == null) { template = IOUtils.toString(Function.class.getResourceAsStream(TEMPLATE_NAME), Utils.ENCODING); } String source = template.replace("$packageName", packageName)// .replace("$className", className)// .replace("$expression", expression); return source; } /** 记录{@link DiagnosticCollector}中的错误内容 */ private CharSequence log(final DiagnosticCollector<JavaFileObject> diagnostics) { final StringBuilder msgs = new StringBuilder(); for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) { msgs.append(diagnostic.getMessage(null)).append("/n"); } return msgs; } }

ExpressionCal$Tester测试表达式x*x+x的运行，具体测试直接计算、java编译并计算、javascript编译并计算的效率，共测试三遍以观察其效率的变化，每一遍中每种方法又用for循环运行10万次计算，忽略打印输出的耗时。测试时间使用微秒为单位，精确度取决于System.nanoTime()，详见其java docs中的说明。测试结果如下：

44.53*44.53+44.53=2027.7451 Time of direct cal 100000 loops: 6461.72微秒. Java src complain time: 604570.13微秒, 44.53*44.53+44.53=2027.7451 Complained source 100000 loops: 5412.14微秒. JS complain time: 23354.09微秒, 44.53*44.53+44.53=2027.7451 Javascript 100000 loops: 8671081.10微秒. ------Test twice------ 7.67*7.67+7.67=66.4529 Time of direct cal 100000 loops: 670.48微秒. Java src complain time: 44715.18微秒, 7.67*7.67+7.67=66.4529 Complained source 100000 loops: 1397.38微秒. JS complain time: 2375.44微秒, 7.67*7.67+7.67=66.4529 Javascript 100000 loops: 8493123.29微秒. ------Test third times------ 74.34*74.34+74.34=5600.4535 Time of direct cal 100000 loops: 572.14微秒. Java src complain time: 39487.42微秒, 74.34*74.34+74.34=5600.4535 Complained source 100000 loops: 1375.04微秒. JS complain time: 1867.56微秒, 74.34*74.34+74.34=5600.4535 Javascript 100000 loops: 8624124.85微秒.

整理得到：

　　可以看出，java直接计算速度超快，java编译并计算速度还是比直接计算慢1倍（不计编译时间），而JS的计算速度比直接计算慢4个数量级，简直惨不忍睹。第一次运行除JS计算外，均比较耗时，其中java第一次编译需要从磁盘上读取template文件，以后则均为内存操作。

　　从测试结果看，如果需要运行一个固定的表达式，可以写死在Java程序中（废话），如果需要计算一个动态变化的表达式，如果计算次数较少（500次以下），JS较为划算，如果计算次数十分巨大，则需要考虑java编译并计算。