Java 9，与 ClassLoader.getSystemClassLoader 的兼容性问题

Question

以下代码将 jar 文件添加到构建路径，它适用于 Java 8。但是，它在 Java 9 中引发异常，该异常与对 URLClassLoader 的强制转换有关。 有什么想法可以解决这个问题吗？ 最佳解决方案将对其进行编辑以与 Java 8 和 9 一起使用。

private static int AddtoBuildPath(File f) {
    try {
        URI u = f.toURI();
        URLClassLoader urlClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
        Class<URLClassLoader> urlClass = URLClassLoader.class;
        Method method = urlClass.getDeclaredMethod("addURL", URL.class);
        method.setAccessible(true);
        method.invoke(urlClassLoader, u.toURL());
    } catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException | MalformedURLException | IllegalAccessException ex) {
        return 1;
    }

    return 0;
}

Answer 1

您遇到了这样一个事实， 即系统类加载器不再是URLClassLoader 。 正如ClassLoader::getSystemClassLoader的返回类型所示，这是一个实现细节，尽管依赖于不可忽略的代码量。

从评论来看，您正在寻找一种在运行时动态加载类的方法。 正如Alan Bateman 指出的那样，这在 Java 9 中无法通过附加到类路径来完成。

您应该考虑为此创建一个新的类加载器。 这有一个额外的好处，您将能够摆脱新类，因为它们没有加载到应用程序类加载器中。 如果您正在针对 Java 9 进行编译，则应该仔细阅读层- 它们为您提供了用于加载全新模块图的清晰抽象。

Answer 2

不久前我偶然发现了这个问题。 与许多人一样，我使用了与问题中类似的方法

private static int AddtoBuildPath(File f)

在运行时动态添加到类路径的路径。 问题中的代码在多个方面可能是糟糕的风格：1）假设ClassLoader.getSystemClassLoader()返回一个URLClassLoader是一个未记录的实现细节，2）使用反射使addURL公开可能是另一个。

动态添加类路径的更简洁方法

如果您需要使用额外的类路径 URL 来通过“ Class.forName ”加载类，一个干净、优雅和兼容（Java 8 到 10）的解决方案如下：

1) 通过扩展 URL 类加载器编写自己的类加载器，有一个公共的addURL方法

public class MyClassloader extends URLClassLoader {

    public MyClassloader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }

    public void addURL(URL url) {
        super.addURL(url);
    }
}

2）声明类加载器的（单例/应用程序范围）对象

private final MyClassloader classLoader;

并通过

classLoader = new MyClassloader(new URL[0], this.getClass().getClassLoader());

注意：系统类加载器是父类。 通过classLoader加载的类知道那些可以通过this.getClass().getClassLoader()加载的类，但classLoader不然。

3）在需要时（动态）添加额外的类路径：

File file = new File(path);
if(file.exists()) {
    URL url = file.toURI().toURL();
    classLoader.addURL(url);
}

4）通过你的单例类加载器实例化对象或你的应用程序

cls = Class.forName(name, true, classLoader);

注意：由于类加载器在加载类（以及父类到其父类）之前尝试委托给父类加载器，因此您必须确保要加载的类对父类加载器不可见，以确保它是通过给定的类加载器加载。 为了更清楚地说明这一点：如果您的系统类路径上有ClassPathB并且稍后将ClassPathB和一些ClassPathA添加到您的自定义classLoader ，那么ClassPathB下的类将通过系统类加载器加载，而ClassPathA下的类对它们来说是未知的。 但是，如果您从系统类路径中删除ClassPathB ，这些类将通过您的自定义classLoader加载，然后 ClassPathA 下的类对于 ClassPathB 下的类是已知的。

5）您可以考虑通过以下方式将类加载器传递给线程

setContextClassLoader(classLoader)

如果线程使用getContextClassLoader 。

Answer 3

如果您只是想读取当前的类路径，例如因为您想启动另一个具有与当前类路径相同的类路径的 JVM，您可以执行以下操作：

object ClassloaderHelper {
  def getURLs(classloader: ClassLoader) = {
    // jdk9+ need to use reflection
    val clazz = classloader.getClass

    val field = clazz.getDeclaredField("ucp")
    field.setAccessible(true)
    val value = field.get(classloader)

    value.asInstanceOf[URLClassPath].getURLs
  }
}

val classpath =
  (
    // jdk8
    // ClassLoader.getSystemClassLoader.asInstanceOf[URLClassLoader].getURLs ++
    // getClass.getClassLoader.asInstanceOf[URLClassLoader].getURLs

    // jdk9+
    ClassloaderHelper.getURLs(ClassLoader.getSystemClassLoader) ++
    ClassloaderHelper.getURLs(getClass.getClassLoader)
  )

默认情况下，不能通过反射访问 $AppClassLoader 类中的最终字段，需要向 JVM 传递一个额外的标志：

--add-opens java.base/jdk.internal.loader=ALL-UNNAMED

Answer 4

Shadov指出了oracle 社区的一个帖子。 有正确答案：

Class.forName("nameofclass", true, new URLClassLoader(urlarrayofextrajarsordirs));

那里提到的警告也很重要：

注意事项：

java.util.ServiceLoader 使用线程的 ClassLoader 上下文 Thread.currentThread().setContextClassLoader(specialloader);

java.sql.DriverManager 确实尊重调用类的 ClassLoader，而不是线程的 ClassLoader。 直接使用 Class.forName("drivername", true, new URLClassLoader(urlarrayofextrajarsordirs).newInstance(); 创建驱动程序

javax.activation 使用线程的 ClassLoader 上下文（对于 javax.mail 很重要）。

Answer 5

我得到了一个在 Java 8 中运行的 Spring Boot 应用程序。我的任务是将它升级到 Java 11 版本。

面临的问题：

引起：java.lang.ClassCastException: jdk.internal.loader.ClassLoaders$AppClassLoader (in module: java.base) cannot be cast to java.net.URLClassLoader (in module: java.base)

使用方法：

创建一个类：

import java.net.URL;

/**
 * This class has been created to make the code compatible after migration to Java 11
 * From the JDK 9 release notes: "The application class loader is no longer an instance of
 * java.net.URLClassLoader (an implementation detail that was never specified in previous releases).
 * Code that assumes that ClassLoader.getSytemClassLoader() returns a URLClassLoader object will
 * need to be updated. Note that Java SE and the JDK do not provide an API for applications or
 * libraries to dynamically augment the class path at run-time."
 */

public class ClassLoaderConfig {

    private final MockClassLoader classLoader;

    ClassLoaderConfig() {
        this.classLoader = new MockClassLoader(new URL[0], this.getClass().getClassLoader());
    }

    public MockClassLoader getClassLoader() {
        return this.classLoader;
    }
}

创建另一个类：

import java.net.URL;
import java.net.URLClassLoader;

public class MockClassLoader extends URLClassLoader {

    public MockClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }

    public void addURL(URL url) {
        super.addURL(url);
    }
}

现在将它设置在主类的当前线程中（就在应用程序的开头）

Thread.currentThread().setContextClassLoader(new ClassLoaderConfig().getClassLoader());

希望这个解决方案对你有用！！！

Answer 6

参考 Edi 的解决方案，这对我有用：

public final class IndependentClassLoader extends URLClassLoader {

    private static final ClassLoader INSTANCE = new IndependentClassLoader();

    /**
     * @return instance
     */
    public static ClassLoader getInstance() {

        return INSTANCE;
    }

    private IndependentClassLoader() {

        super(getAppClassLoaderUrls(), null);
    }

    private static URL[] getAppClassLoaderUrls() {

        return getURLs(IndependentClassLoader.class.getClassLoader());
    }

    private static URL[] getURLs(ClassLoader classLoader) {

        Class<?> clazz = classLoader.getClass();

        try {
            Field field = null;
            field = clazz.getDeclaredField("ucp");
            field.setAccessible(true);

            Object urlClassPath = field.get(classLoader);

            Method method = urlClassPath.getClass().getDeclaredMethod("getURLs", new Class[] {});
            method.setAccessible(true);
            URL[] urls = (URL[]) method.invoke(urlClassPath, new Object[] {});

            return urls;

        } catch (Exception e) {
            throw new NestableRuntimeException(e);
        }

    }
}

在 Eclipse 中运行，您需要将 VM Arguments 设置为 JUnit Launch/Debug Configuration。 通过命令行使用 maven 运行您有两个选择：

选项 1
将以下行添加到 pom.xml ：

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.16</version>
                <configuration>
                    <argLine>--add-opens java.base/jdk.internal.loader=ALL-UNNAMED</argLine>
                </configuration>
            </plugin>

选项 2

运行mvn test -DargLine="-Dsystem.test.property=--add-opens java.base/jdk.internal.loader=ALL-UNNAMED"

Answer 7

我找到了这个，并为我工作。

String pathSeparator = Syste .getProperty("path.separator"); String[] classPathEntries = System.getProperty("java.class.path") .split(pathSeparator);

来自网站https://blog.codefx.org/java/java-11-migration-guide/#Casting-To-URL-Class-Loader

Answer 8

下面的代码片段将有助于获得所需的输出。

String classpath = System.getProperty("java.class.path");
String[] classPathValues = classpath.split(File.pathSeparator);
    for (String classPath: classPathValues) {
      System.out.println(classPath);
    }

Answer 9

还有这个家伙的文章对我有帮助。 我找不到这篇文章，但是……在这里： https : //github.com/CGJennings/jar-loader

这是指南的一部分，里面有一个 jar，你可以阅读他的指南并进行设置。

我只是自己尝试下载包含类文件的 jar 文件

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.jar.JarFile;

public final class classname{

    public static void premain(String agentArgs, Instrumentation instrumentation) {
        loadedViaPreMain = true;
        agentmain(agentArgs,instrumentation);
    }

    public final static void addToClassPath(File jarfile)throws IOException{inst.appendToSystemClassLoaderSearch(new JarFile(jarfile));}
    public final static void agentmain(String agentArgs, Instrumentation instrumentation) {
      if (instrumentation == null){throw new NullPointerException("instrumentation");}
      if (inst == null) {inst = instrumentation;}
    }
    private static Instrumentation inst;
    private static boolean loadedViaPreMain = false;
}

我只是尝试自己将这些代码打包为一个包，然后使用 -javaagent:plugin......jar 选项启动应用程序类，然后调用此函数。它不会改变我的类路径。我可能在这里遗漏了一些细节.

希望你可以让它工作。