java - Class.forName(name, instantiation, classLoader) 不会将类添加到类路径

Question

我正在生成.java类文件在运行时生成，并且需要立即在代码中使用这些类。所以我编译了.java使用编译器 API 来制作 .class 的类文件:

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();

StandardJavaFileManager manager = compiler.getStandardFileManager(diagnostics, null, null);

File file = new File("path to file");

Iterable<? extends JavaFileObject> sources = manager.getJavaFileObjectsFromFiles(Arrays.asList(file));

CompilationTask task = compiler.getTask(null, manager, diagnostics, null, null, sources);

task.call();

manager.close();

然后我需要使用 Class.forName() 获取对这些已编译类的引用，但是如果我打电话Class.forName("com.foo.Bar")它抛出 ClassNotFoundException ，假设是因为新的.class文件未添加到 classpath我寻找向 classpath 添加类的方法在运行时。我遇到了一些与这个概念相关的歧义:

1. 这种方法(首先使用编译器 API 编译 .java 文件，然后在第二步将其添加到类加载器中)是否正确？能够立即在代码中使用该类。

2. AFAIK，有两种方法可以在运行时将类动态加载到类路径中:一种是使用像这样的自定义类加载器:(我编译时出错，因为它提示 BuiltinClassLoader没有 addURL 方法):

    // Get the ClassLoader class
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    Class<?> clazz = cl.getClass();

    // Get the protected addURL method from the parent URLClassLoader class
    Method method = clazz.getSuperclass().getDeclaredMethod("addURL", new Class[] { URL.class });

    // Run projected addURL method to add JAR to classpath
    method.setAccessible(true);
    method.invoke(cl, new Object[] { cls });

另一种方法是使用Class.forName(name, instantiation, classLoader)将类添加到类路径(同时也给出类引用)。由于如上所述出现编译器错误(Java 11)，我无法应用第一种方法。关于第二种方法，会Class.forName(name, instantiation, classLoader)将新类附加到 classpath如果我们像这样调用默认类加载器？ :

Class.forName("com.foo.Bar",true, ClassLoader.getSystemClassLoader());
// or:
Class.forName("com.foo.Bar",true, ApiHandler.class.getClassLoader());

这对我不起作用。上述类加载器参数的哪种变体是正确的，为什么这些不起作用？是否必须创建自定义类加载器并将其传递给 Class.forName() ？

3.我正在制作 .java com.foo 内的文件封装在 src eclipse 项目的文件夹。他们编译的.class文件也会在同一文件夹中生成(使用编译器 API)。当我使用 eclipse 刷新项目时(右键单击项目 -> 刷新)相关的 .class文件将在 target/classes 中生成文件夹中，此时可以通过代码访问类(例如使用 Class.forName("com.foo.Bar) 。如果我在 .class 文件夹中生成 target/classes 文件(通过编译器 API)，这些类将无需识别即可识别将它们引入类路径？

<小时/>

更新:

通过保存受人尊敬的.class，我能够在我的代码中使用编译后的类。文件在 target/classes项目的上面第三个问题中提到的文件夹。 (通过将 -d 选项添加到编译器的 getTask() 方法中:

Iterable<String> options = Arrays.asList( new String[] { "-d", System.getProperty("user.dir") + "/target/classes/"} );
.
.
.

CompilationTask task = compiler.getTask(null, manager, diagnostics, options, null, sources);

这样，似乎甚至不需要使用 classLoader 将类添加到类路径；因为可以使用简单的 Class.forName() 访问该类。 你如何解释这一点？

Class<?> cls1 = Class.forName("com.foo.Bar");

当然，也可以通过 ClassLoader 方式:

ClassLoader classLoader = ClassLoader.getSystemClassLoader(); 

Class<?> cls = classLoader.loadClass("com.foo.Bar");

Answer 1

最安全的解决方案是创建一个新的 ClassLoader 实现并通过新的加载器加载生成的类，如this answer所示.

但是从 Java 9 开始，如果尚未定义/加载具有该名称的类，则可以在您自己的上下文中(即在同一包中)定义类。如上所述，这样的类定义甚至可以取代类路径上的定义，只要它尚未加载。因此，不仅后续的 Class.forName(String) 调用将解析为此类定义，甚至非反射引用也会解析为该类定义。

这可以通过以下程序进行演示。

class Dummy { // to make the compiler happy
    static native void extensionMethod();
}
public class CompileExtension {
    public static void main(String[] args) throws IOException, IllegalAccessException {
        // customize these, if you want, null triggers default behavior
        DiagnosticListener<JavaFileObject> diagnosticListener = null;
        Locale locale = null;

        // the actual class implementation, to be present at runtime only
        String class1 =
            "class Dummy {\n"
          + "    static void extensionMethod() {\n"
          + "        System.out.println(\"hello from dynamically compiled code\");\n"
          + "    }\n"
          + "}";
        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,
            Set.of(Files.createTempDirectory("compile-test").toFile()));
        JavaCompiler.CompilationTask task = c.getTask(null, fm,
            diagnosticListener, Set.of(), Set.of(),
            Set.of(new SimpleJavaFileObject(
                URI.create("string:///Class1.java"), JavaFileObject.Kind.SOURCE) {
                    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
                        return class1;
                    }
                }));

        if(task.call()) {
            FileObject fo = fm.getJavaFileForInput(
                StandardLocation.CLASS_OUTPUT, "Dummy", JavaFileObject.Kind.CLASS);
            // these are the class bytes of the first class
            byte[] classBytes = Files.readAllBytes(Paths.get(fo.toUri()));
            MethodHandles.lookup().defineClass(classBytes);

            Dummy.extensionMethod();
        }
    }
}

Dummy 定义的存在只是为了能够在编译时插入对所需方法的调用，而在运行时，动态定义的类会在方法被调用之前取代它的位置。

但请小心处理。如前所述，自定义类加载器是最安全的解决方案。通常，您应该通过始终存在的接口(interface)创建对扩展的编译时引用，并且仅动态加载实现，可以在运行时将其强制转换为接口(interface)，然后通过接口(interface)定义的 API 使用。