动态编译Java代码，该代码对特定classloader加载的类具有依赖性

Question

我们有能力动态编译Java代码。我至少知道java-runtime compiler和inmemoryjavacompiler

，但似乎它们无法编译依赖某些类负载的某些类的类。

是否可以动态编译仅在特定classloader中可用的类的Java代码？假设：

ClassLoader classloader = ... // only this CL can load class 'com.External'
String source = "public class MyClass extends com.External {}";
Class<?> compiled = DesiredDynamicCompiler.compile("MyClass", source, classloader); 
// last argument is like an information to compiler where to search all dependencies

---

提供更多的见解：我想在java中做什么，groovyClassloader在grovy中可以做什么：

GroovyClassLoader groovyClassLoader = new GroovyClassLoader(classLoader);
Class<?> parsedClass = groovyClassLoader.parseClass("some source");

该代码可以解析仅取决于仅在指定的classloader中可用的类的类。

Answer 1

无法使用ClassLoader作为参考，除非它能够提供其定义类的类字节。即，如果您具有代表顶级类的Class实例，则可以使用classInstance.getResourceAsStream(classInstance.getSimpleName()+".class")尝试使用类字节。如果您可以访问组成动态类的字节，则可以通过JavaFileManager实现使Java编译器可用。

编译器API是标准API的一部分，不需要第三方库。以下代码通过首先编译测试类来证明这一点

// customize these, if you want, null triggers default behavior
DiagnosticListener<JavaFileObject> diagnosticListener = null;
Locale locale = null;
// the first class, to be present at runtime only
String class1 = "package test;npublic class Class1 {}";
JavaCompiler c = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm
    = c.getStandardFileManager(diagnosticListener, locale, Charset.defaultCharset());
// define where to store compiled class files - use a temporary directory
fm.setLocation(StandardLocation.CLASS_OUTPUT, Collections.singleton(
        Files.createTempDirectory("compile-test").toFile()));
JavaCompiler.CompilationTask task = c.getTask(null, fm,
    diagnosticListener, Collections.emptySet(), Collections.emptySet(),
    Collections.singleton(new SimpleJavaFileObject(
        URI.create("string:///Class1.java"), Kind.SOURCE) {
            public CharSequence getCharContent(boolean ignoreEncodingErrors) {
                return class1;
            }
        }));
if(task.call()) {
    FileObject fo = fm.getJavaFileForInput(
            StandardLocation.CLASS_OUTPUT, "test.Class1", Kind.CLASS);
    // these are the class bytes of the first class
    byte[] class1bytes = Files.readAllBytes(Paths.get(fo.toUri()));
    // the actual task: define a class dependent on the first class
    String class2 = "package test;npublic class Class2 { Class1 variable; }";
    // create a file object representing the dynamic class
    JavaFileObject jo = new SimpleJavaFileObject(
        URI.create("runtime:///test/Class1.class"), Kind.CLASS) {
            @Override public InputStream openInputStream() throws IOException {
                return new ByteArrayInputStream(class1bytes);
            }
        };
    // and a custom file manager knowing how to locate that class
    JavaFileManager myFM = new ForwardingJavaFileManager(fm) {
        @Override
        public JavaFileObject getJavaFileForInput(
                JavaFileManager.Location location, String className, Kind kind)
                throws IOException {
            if(location==StandardLocation.CLASS_PATH&&className.equals("test.Class1")) {
                return jo;
            }
            return super.getJavaFileForInput(location, className, kind);
        }
        @Override
        public boolean hasLocation(JavaFileManager.Location location) {
            return location==StandardLocation.CLASS_PATH || super.hasLocation(location);
        }
        @Override
        public Iterable list(JavaFileManager.Location location,
                String packageName, Set kinds, boolean recurse) throws IOException {
            if(location==StandardLocation.CLASS_PATH
                    && (packageName.equals("test") || recurse&&packageName.isEmpty())) {
                return Collections.singleton(jo);
            }
            return super.list(location, packageName, kinds, recurse);
        }
        @Override
        public String inferBinaryName(
                JavaFileManager.Location location, JavaFileObject file) {
            if(file==jo) return "test.Class1";
            return super.inferBinaryName(location, file);
        }
    };
    // compile the second class using the custom file manager to locate dependencies
    task = c.getTask(null, myFM,
        diagnosticListener, Collections.emptySet(), Collections.emptySet(),
        Collections.singleton(new SimpleJavaFileObject(
            URI.create("string:///Class2.java"), Kind.SOURCE) {
                public CharSequence getCharContent(boolean ignoreEncodingErrors) {
                    return class2;
                }
            }));
    if(task.call()) {
        fo = fm.getJavaFileForInput(
            StandardLocation.CLASS_OUTPUT, "test.Class2", Kind.CLASS);
        // there we have the compiled second class
        byte[] class2bytes = Files.readAllBytes(Paths.get(fo.toUri()));
    }
}

当然，这仅是为了证明原则。您肯定想为文件对象创建出厂方法，并使用Map s记住它们，等等。

也可以用自定义内存存储替换临时目录。但是关键点仍然是编译器需要能够访问类字节。它不会使用已加载的运行时类。

Answer 2

您应该在类路径上具有所有依赖关系。无论如何，您引用的工具在封面下使用Java编译器API。

它不与当前JVM内存中的类交互，它仅搜索classPath中的依赖项。

您可以关注compilerutils-> com.sun.tools.javac.api.javactool->再以某种感觉。

您可以尝试做的一件事是将您动态编译的依赖项倾倒到ClassPath中的适当位置为.class文件，以便您的汇编过程会拾取它们。