在使用高版本的时候, 总会不可避免的接触到模块系统, 比如反射操作 java.base 已经十分困难. 既然 JDK 内部可以享受到模块的保护, 那么我们自己的代码是否也可以享受到模块系统的保护呢

当然可以，而且也不是非常麻烦。

使用模块，你将面对以下问题

• 得到反射保护, 外部代码将不能通过反射强行修改/调用私有成员
• 更严格的访问控制, 不能直接访问非 required 的模块
• 失去 --add-opens=....=ALL-UNNAMED 的归属判断
• 需要专门的 ClassLoader / 需要自行实现 ClassLoader

使用模块的适用情况

• 需要编写严格的附属(插件)系统
• 需要保护自身代码/保护自身内存空间
• 觉得弄着好玩

定义一个模块

注: 此处的定义指的是, 通过运行时代码在运行时定义一个模块.
而不是大多数资料说的直接写一个 module-info.java

要定义一个模块, 首先需要一个模块的描述符文件 (ModuleDescriptor), 可以从以编码文件读取 (ModuleDescriptor.read(InputStream) <- module-info.class), 也可以在运行时动态生成一个(ModuleDescriptor.newModule("name_of_module").build())

jvm 通过包来区分模块, 而一个模块的全部包都需要提前指定, jvm 才会为这些包分配到一个模块内

var moduleDescriptor = ModuleDescriptor.newModule("my.custom_module")
    .packages(Set.of("io.github.karlatemp.jmse.main"))
    .exports("io.github.karlatemp.jmse.main")
    .build();

这里我们已经拥有了一个模块的描述符, 现在我们还需要一个模块描述的引用, 以及一个模块查找器以让 jvm 可以找到我们的模块

var myModuleReference = new ModuleReference(
    moduleDescriptor, null
) {
    @Override public ModuleReader open() throws IOException {
        throw new UnsupportedOperationException();
    }
}
var myModuleFinder = new ModuleFinder() {
    @Override
    public Optional<ModuleReference> find(String name) {
        if (name.equals(moduleDescriptor.name())) {
            return Optional.of(myModuleReference);
        }
        return Optional.empty();
    }

    @Override
    public Set<ModuleReference> findAll() {
        return Set.of(myModuleReference);
     }
};

最后，定义一个模块

var bootLayer = ModuleLayer.boot();
var myConfiguration = bootLayer.configuration().resolve(
    myModuleFinder, ModuleFinder.of(), Set.of(moduleDescriptor.name())
);
var classLoader = ClassLoader.getSystemClassLoader();
var controller = ModuleLayer.defineModules(
    myConfiguration, List.of(bootLayer), $ -> classLoader
);

Class.forName("io.github.karlatemp.jmse.main.ModuleMain", false, classLoader)
    .getMethod("launch")
    .invoke(null);

ServiceLoader / Class.forName(Module, String)

还记得 需要专门的 ClassLoader / 需要自行实现 ClassLoader 吗, 虽然在上文已经成功定义了一个模块，但是只要使用 ServiceLoader / Class.forName(Module, String), 那么将无法找到对应的类, 因为一般的 ClassLoader 并没有专门处理动态加载的模块

Analyze

通过进行调用分析, 最终可以发现以上两个东西最终都进入到了下面的方法

public class ClassLoader {
    final Class<?> loadClass(Module module, String name) {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                c = findClass(module.getName(), name);
            }
            if (c != null && c.getModule() == module) {
                return c;
            } else {
                return null;
            }
        }
    }
    protected Class<?> findClass(String moduleName, String name) {
        if (moduleName == null) {
            try {
                return findClass(name);
            } catch (ClassNotFoundException ignore) { }
        }
        return null;
    }
}

不难发现, 由于默认没有处理模块, 导致指定搜索模块的时候将搜索不到动态定义的模块

而 jdk.internal.loader.ClassLoader$AppClassLoader 并没有处理通过 ModuleLayer.defineModule 定义的模块, 于是也不能直接将模块定义到系统类加载器

自行实现类加载器

自行实现类加载器十分简单，只需要

public class MyCustomClassLoader extends URLClassLoader {
    String moduleName;

    @Override
    protected Class<?> findClass(String moduleName, String name) {
        // System.out.println("Find class: " + moduleName + "/" + name);
        if (this.moduleName.equals(moduleName)) {
            try {
                return findClass(name);
            } catch (ClassNotFoundException ignored) {
            }
        }
        return super.findClass(moduleName, name);
    }
}

使用 JDK 内置的类加载器

只需要实现 ModuleReference.open(): ModuleReader, 然后使用

var controller = ModuleLayer.defineModulesWithOneLoader(
        myConfiguration,
        List.of(bootLayer),
        ClassLoader.getSystemClassLoader().getParent()
);
var classLoader = controller.layer().findLoader(moduleDescriptor.name());

即可使用 JDK 内置的内加载器

完整参考

• java-module-system-explore
  • BootModuleByStandard.java
  • MyCustomClassLoader.java