#头条创作挑战赛#

Java 的一个重要特性是动态的类加载机制。通过在运行时动态地加载类，Java 程序可以实现很多强大的功能。下面通过一个具体的实例来说明 Java 程序中，如何动态地编译 Java 源代码、加载类和执行类中的代码。这里的代码示例适用的版本是 Java 8。

示例所实现的功能很简单，就是对表达式求值。输入的是类似 1 + 1 或 3 * (2 + 3) 这样的表达式，返回的是表达式的值。示例的做法是动态创建一个 Java 源文件，编译该文件生成 class 文件，加载 class 文件之后再执行。比如，需要求值的表达式是 1 + 1，那么所生成的 Java 源文件如下所示，其中 1 + 1 的部分是动态的。

public class Calculator {
    public static Object calculate() {
        return 1 + 1;
    }
}

我们只需要编译该源文件，加载编译之后的 class 文件，再通过反射 API 来调用其中的 calculate 方法就可以得到表达式求值的结果。

编译

第一步是动态生成 Java 源代码并编译。生成 Java 源代码比较简单，直接用字符串连接就可以了。当然了，在生成逻辑比较复杂时，推荐的做法是使用字符串模板引擎，如 Handlebars。在下面的代码中，getJavaSource 方法生成 Java 源代码，compile 方法进行编译。

在进行编译的时候，使用的是 JDK 标准的 JavaCompiler 接口。从源代码字符串中创建了一个 JavaFileObject 对象作为编译时的源代码单元。编译时的选项 -d 指定了编译结果的输出路径，这里是一个临时文件夹。compile 方法的返回值是一个 Pair 对象，包含了 class 文件的路径，以及随机生成的 Java 包的名称。

public class DynamicCompilation {

  private static final String CLASS_NAME = "Calculator";

  public static Pair compile(String expr) throws IOException {
    String packageName = "z" + UUID.randomUUID().toString().replace("-", "");
    Path outputPath = Files.createTempDirectory("expr");
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null,
        null, null);
    compiler.getTask(null, fileManager, null, ImmutableList.of(
                "-d", outputPath.toAbsolutePath().toString()
            ), null,
            Collections.singletonList(
                new StringContentJavaFileObject(CLASS_NAME,
                    getJavaSource(packageName, expr))))
        .call();
    return Pair.of(outputPath, packageName + "." + CLASS_NAME);
  }

  private static String getJavaSource(String packageName, String expr) {
    return "package " + packageName + "; "
        + "public class " + CLASS_NAME
        + " { public static Object calculate() {  "
        + "return " + expr + "; }" +
        "}";
  }
}

上面的代码用到了一个帮助类 StringContentJavaFileObject，表示从字符串创建的 JavaFileObject 对象。

public class StringContentJavaFileObject extends SimpleJavaFileObject {

  private final String content;

  public StringContentJavaFileObject(String name, String content) {
    super(URI.create("string:///" + name + Kind.SOURCE.extension),
        Kind.SOURCE);
    this.content = content;
  }

  @Override
  public CharSequence getCharContent(boolean ignoreEncodingErrors) {
    return content;
  }
}

加载

编译完成之后的第二步是动态加载类。这一步并没有实现自定义的类加载器，而且使用内置的系统类加载器。系统类加载器通过 ClassLoader.getSystemClassLoader() 方法来获取。系统类加载器在 classpath 上查找类。这里用了一个比较 hack 的技巧来动态修改系统类加载器的 classpath。

在下面的代码中，ClasspathUpdater 的 addPath 方法可以把一个 Path 对象表示的路径，添加到系统类加载器的查找路径中。这是因为系统类加载器自身是 URLClassLoader 类型的加载器，其中的 addURL 方法可以添加新的查找路径。只不过 addURL 方法是 protected，这里通过反射 API 来进行调用。

public class ClasspathUpdater {

  public static void addPath(Path path) {
    URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
    try {
      Method method = URLClassLoader.class.getDeclaredMethod("addURL",
          URL.class);
      method.setAccessible(true);
      method.invoke(classLoader, path.toUri().toURL());
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

}

上面介绍的 ClasspathUpdater 类中的使用技巧，只对 Java 8 生效。在 Java 9 引入模块系统时，对系统类加载器进行了修改。系统类加载器被替换成了应用类加载器。应用类加载器不再是 URLClassLoader 类型了，就不能使用这个技巧了。

执行

最后一步就是执行动态加载的 Java 类。这一步比较简单，只需要用 Class.forName 方法来查找 Java 类，再找到对应的 Method 对象，直接调用即可。下面的代码给出了示例。

public class Invoker {

  public static Object invoke(String className) {
    try {
      Method method = Class.forName(className).getDeclaredMethod("calculate");
      return method.invoke(null);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
}

完整的执行过程

最后把整个流程串起来。在下面的代码中，需要求值的表达式是 (1 + 1) * 3 / 5.0。首先调用 DynamicCompilation.compile 方法进行动态编译，得到 class 文件的路径和完整的类名。class 文件的路径通过 ClasspathUpdater.addPath 方法添加到 classpath 中。完整的类名则传递给 Invoker.invoke 方法来执行。最后输出的结果是表达式的值。

public class Main {

  public static void main(String[] args) throws IOException {
    Pair result = DynamicCompilation.compile("(1 + 1) * 3 / 5.0");
    ClasspathUpdater.addPath(result.getLeft());
    System.out.println(Invoker.invoke(result.getRight()));
  }
}