使用自定义类加载器从分解模块加载类

Question

我一直在Java玩简单的自定义类加载器，到目前为止，对于非模块相关的类来说，一切都按照预期工作。但是，我似乎找不到任何方法来使用我的类加载器从模块加载类，即使与模块相关的find*()方法已经被重载。我尝试做的是从模块“HelloModularWorld”加载一个类，并运行它的main。然而，当我指定包所在的目录时，它将“正常”加载，并报告为在未命名模块中。我错过了什么？

类加载器只是从文件系统的其他地方加载类，没有什么特别的。

类加载器实现：

package arch.classloaders;

import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;

public class ModifiableClassLoader extends ClassLoader {
    private File searchPath;
    //...other ctors...
    public ModifiableClassLoader(File path, String name, ClassLoader parent) {
        super(name, parent); //Delegate to parent classloader as required.
        if (!path.isDirectory()) throw new IllegalArgumentException("Path must be a directory");
        searchPath = path;
    }

    public void setPath(File newPath) {...}

    public File getPath() {...}

    //Responsible for actual loading
    public Class<?> findClass(String binName) throws ClassNotFoundException {
        File classfile = new File(searchPath.getPath() + File.separator 
                + binName.replace('.', File.separatorChar) + ".class");
        byte[] buf;
        FileInputStream fis;
        try {
            fis = new FileInputStream(classfile);
            buf = fis.readAllBytes();
            fis.close();
        } catch (IOException e) {
            throw new ClassNotFoundException("Error in defining " + binName + " in " + searchPath.getPath(),e);
        }
        return defineClass(binName, buf, 0, buf.length);
    }

    //Modules are expected to be in a folder with the same name as the module.
    //e.g. module hellomodularworld is expected to be in a folder
    //<SEARCHPATH>/<MODNAME>/
    //NOTE: Module-overloaded methods return null rather than throw when class isn't found.
    public Class<?> findClass(String modName, String binName) {
        if (null == modName) {
            try {
                return findClass(binName);
            } catch (ClassNotFoundException e) {
                return null;
            }
        }
        File classfile = new File(searchPath.getPath() + File.separator 
                + modName + File.separator
                + binName.replace('.', File.separatorChar) + ".class");
        byte[] buf;
        FileInputStream fis;
        try {
            fis = new FileInputStream(classfile);
            buf = fis.readAllBytes();
            fis.close();
        } catch (IOException e) {
            return null;
        }
        return defineClass(binName, buf, 0, buf.length);
    }

    //Non-module
    public URL findResource(String resPath) {...}

    //Module version
    public URL findResource(String modName, String resPath) throws IOException {...}

    //Enumeration version; does nothing.
    public java.util.Enumeration<URL> findResources(String resPath) {...}
}

测试代码：

public class Test {
    public static void main(String[] args) {
        ModifiableClassLoader mcl = new ModifiableClassLoader(
                new File("C:\\Users\\archd\\Desktop\\"));
        try {
            Class<?> clazz = mcl.loadClass(
                    "hellomodularworld/com.archdukeliamus.hellomodularworld.HelloWorld"
            );
            java.lang.reflect.Method mth = clazz.getMethod("main", String[].class);
            mth.invoke(null,new Object[] {null});
            System.out.println(clazz.getModule().getName());
        } catch (...) {
                //omitted
        }
}

在线类<？>clazz=mcl.loadClass（“hellomodularworld/com.archdukeliamus.hellomodularworld.helloworld”）；我已尝试：

• “hellomodularworld/com.archdukeliamus.hellomodularworld.helloworld”-不工作。ClassNotFoundException.
• “hellomodularworld.com.archdukeliamus.hellomodularworld.helloworld”-NoClassDefoundException。
  com/archdukeliamus/hellomodularworld/helloworld（错误名称：hellomodularworld/com/archdukeliamus/helloworld)
• “com.archdukeliamus.hellomodularworld.helloworld”-按预期工作（适当更改classloading文件夹），但使用未命名的模块。

编辑：module-info.java

module hellomodularworld {

}

测试类不在任何模块中。（我不完全确定这有什么关系，我应该得到一个“这个包不导出”的例外，但我没有得到。）

编辑2：修改模块，以包含导出com.archdukeliamus.hellomodularworld；。结果没有变化。

Answer 1

模块加载是与类加载分离的过程。要在运行时加载模块，您需要使用ModuleFinder类创建一个新的模块层，该类提供了来自文件系统的路径（在本例中为磁盘）。然后，您需要创建一个配置来解析模块。为了确保模块加载过程的健全性，您将需要派生引导配置。然后需要创建配置，包括一个modulefinder来告诉要在哪里找到模块，以及一组要解析的模块。然后实例化您希望用来加载这些模块的类的类加载器，并将其传递给define modules方法。最后，实例化您的类。

新测试：

package arch.classloaders;

import java.lang.module.*;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.io.*;
import java.nio.*;
import java.nio.file.*;
import java.util.*;

public class Test2 {
    public static void main(String[] args) {
        //Get paths to module, and instantiate a ModuleFinder.
        Path pth = FileSystems.getDefault().getPath("C:\\Users\\archd\\Desktop");
        ModuleFinder mf = ModuleFinder.of(pth);
        //Create a new Configuration for a new module layer deriving from the boot configuration, and resolving
        //the "hellomodularworld" module.
        Configuration cfg = ModuleLayer.boot().configuration().resolve(mf,ModuleFinder.of(),Set.of("hellomodularworld"));
        //Create classloader
        ModifiableClassLoader mcl = new ModifiableClassLoader(
                new File("C:\\Users\\archd\\Desktop\\"));
        //make the module layer, using the configuration and classloader.
        ModuleLayer ml = ModuleLayer.boot().defineModulesWithOneLoader(cfg,mcl);
        //Show the configuration.
        System.out.println(ml.configuration()); //prints "hellomodularworld"
        try {
            //load and run class
            Class<?> clazz = ml.findLoader("hellomodularworld").loadClass(
                    "com.archdukeliamus.hellomodularworld.HelloWorld"
            );
            java.lang.reflect.Method mth = clazz.getMethod("main", String[].class);
            mth.invoke(null,new Object[] {null});
            //show the module this class is part of and list packages
            System.out.println(clazz.getModule()); //prints "module hellomodularworld"
            for (String pkgn : clazz.getModule().getPackages()) {
                System.out.println(pkgn); //prints "com.archdukeliamus.hellomodularworld"
            }
        } catch (ClassNotFoundException e) {
            ...omitted...
        }
    }
}

有趣的是，这仍然没有调用重载的基于模块的findClass（）方法，尽管它似乎可以工作。