我有三个模块：模块-a、模块-b、模块-c。Module-a 和 module-b 位于引导层。module-c 层我自己创建。

Module-a 有一个接口com.mod-a.Service，在它的 module-info 中我有：

module module-a {
    exports com.mod-a;
}

Module-c 实现com.mod-a.Service并在其模块信息中我有：

module module-c {
    requires module-a;
    provides com.mod-a.Service with com.mod-c.ServiceImpl;
}

模块-b 使用模块-c 创建新层，并调用模块-c 服务。在它的模块信息中，我有：

module module-b {
    requires module-a;
    requires java.management;
    requires slf4j.api;
    uses com.mod-a.Service;
}

在 module-b 中，我使用 module-c 以这种方式创建新层：

ModuleFinder finder = ModuleFinder.of(moduleCPath);
ModuleLayer parent = ModuleLayer.boot();
Configuration cf = parent.configuration().resolve(finder, ModuleFinder.of(), Set.of("module-c"));
ClassLoader scl = ClassLoader.getSystemClassLoader();
ModuleLayer layer = parent.defineModulesWithOneLoader(cf, scl);
//the following line prints "module-c" …

这些状态中的每一个的文档如下：

ResolvedModule

已解析模块图中的模块。ResolvedModule定义了配置方法来获取解析模块所在的配置。它定义了引用方法来获取对模块内容的引用。

Module

表示一个运行时模块，命名或未命名。

问：- 这两者什么时候不同，是在编译时还是运行时，还是只是模块的不同表示？

另一方面，模块路径定义

编译时或运行时环境中内置的模块，连同那些由模块路径上的工件定义的模块，统称为可观察模块的宇宙。

问：- 所有这些都相关吗？有人可以举例说明如何以及在什么时间解释这个概念吗？

我在将项目迁移到Java 9 时遇到了问题。

更新 Java 9 后，我尝试运行项目，但遇到编译器错误：-

Error:(6, 1) java: package javax.annotation is not visible 
(package javax.annotation is declared in module java.xml.ws.annotation, which is not in the module graph) 

但我找到了解决方法。我添加了lombok.config文件。

然后将module-info.java文件添加到项目编译器后再次显示错误

Error:(10, 26) java: variable title not initialized in the default constructor

项目示例：

我们有实体Store：

@AllArgsConstructor
@Getter
public class Story {
    private final String title;
}

在 root 的包中，我有module-info.java内容：

module javanine {
    requires lombok;
}

在 root 的项目中，我有 lombok.config …

我有一个这样的项目：

\---main
    \---src
        \---com.foo
            \---UnnamedStart.java
\---api
    \---src
        \---com.foo.api
            \---ApiInterface.java
        \---module-info.java
\---impl
    \---src
        \---com.foo.impl
            \---ApiInterfaceImpl.java
        \---module-info.java

的实现UnnamedStart.java是：

public static void main(String[] args) {
    ServiceLoader<ApiInterface> services = ServiceLoader.load(ApiInterface.class);
    ...
}

请注意，main是未命名的模块。

api/src/module-info.java 是：

module com.foo.api {
     exports com.foo.api;
}

并且impl/src/module-info.java是：

更新 1.1 - 下面的代码更新见评论，添加requires

更新 1.2 - 下面的代码已更新，在创建问题时provides A with B更改为provides B with A错误，原本没问题

module com.foo.impl {
     requires com.foo.api; //added (update 1.1)
     provides com.foo.impl.ApiInterface
         with com.foo.api.ApiInterfaceImpl; //vice versa (update 1.2)
} …

我使用 Java-8 编译器编译了以下代码：

package pack;
import sun.util.calendar.CalendarUtils;
public class A {
    public static void main(String[] args) {
        System.out.println(CalendarUtils.isGregorianLeapYear(2018));
    }
}

我使用 Java-8 编译器将上述代码编译为：

gyan@gyan-pc:~/codes/java$ ~/Documents/softwares/Linux/jdk1.8.0_131/bin/javac -d . a.java
a.java:2: warning: CalendarUtils is internal proprietary API and may be removed in a future release
import sun.util.calendar.CalendarUtils;
                        ^
a.java:9: warning: CalendarUtils is internal proprietary API and may be removed in a future release
        System.out.println(CalendarUtils.isGregorianLeapYear(2018));
                           ^
2 warnings

我的默认 Java 解释器的版本：

gyan@gyan-pc:~/codes/java$ java -version
java version "9.0.1"
Java(TM) SE Runtime Environment (build 9.0.1+11) …

我创建了一个com.company.ep位于源文件夹中的模块com.company.ep(是的,我已从srcBuild Path中删除并删除它).在源文件夹中,我有几个包如下:

com.company.ep    <--- root source folder
    com.company.ep.main    <--- package 1
    com.company.ep.model   <--- package 2
    com.company.ep.view    <--- package 3
    // ... more packages
    module-info.java

主类位于包中com.company.ep.main.Main.在我的module-info.java配置依赖项:

module com.company.ep {
    exports com.company.ep.main;
    exports com.company.ep.model;
    exports com.company.ep.view;
    // ... more exports
    requires javafx.controls;
    requires javafx.graphics;
}

当我尝试启动我的程序时,Eclipse告诉我:

Error occurred during initialization of boot layer
java.lang.module.FindException: Module javafx.controls not found, required by com.company.ep

所以我尝试在命令提示符下运行它:

java -p d:\Applications\openjfx-sdk-11\lib;bin -m com.company.ep/com.company.ep.main.Main

bin是Eclipse的输出文件夹,它工作.

所以我去了 …

我正在开发一个面向 JDK 8 的 Java 库，我正在使用 OpenJDK 11 在 Gradle 5 中构建它。为了面向 JDK 8，我是 javac 的--release选项。

但是，我也希望我的库与 JPMS 兼容。换句话说：

• 我想提供一个module-info.class编译--release 9（Stephen Colebourne's scale 中的选项 3 ），
• 而其余的都是用--release 8.

MCVE

构建.gradle：

plugins {
    id 'java'
    id 'org.javamodularity.moduleplugin' version '1.4.1' // *
}

repositories {
    mavenCentral()
}

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.6'
}

compileJava.options.compilerArgs.addAll(['--release', '9']) // **

*org.javamodularity.moduleplugin设置--module-path为compileJava

** 目前还没有 Gradle DSL --release：#2510

src/main/java/module-info.java： …

我正在尝试在 JAVA11 中重新编译 JAVA8 代码。获得以下编译错误。

错误：对模块的引用不明确 private Module module; ，com.module 中的接口 com.module.Module 和 java.lang 中的类 java.lang.Module 匹配

刚接触 Java 无法完全理解根本原因。任何信息都会有很大帮助。

从Java 9开始，引入了模块系统，从而使JRE的单独提供变得多余。

通过，似乎仍然可以下载它。例如，现在从这里开始Java 9存档 此外，这里仅指出：

重组JDK和JRE运行时映像，以明确区分开发人员，部署人员和最终用户可以依赖并适当修改的文件，与实现内部的文件相反，这些文件可以更改而无需更改注意。

新的映像结构消除了这种区别：JDK映像只是运行时映像，恰好包含JDK历史上发现的全套开发工具和其他项目。

因此，没有谈论彻底清除。来自：jdk-9

当您安装jdk-9时，public jre-9也将自动安装。

另外，我还以为从Java 9开始就应该始终使用jlink创建自定义运行时，但是现在看来似乎只从Java 11开始执行。从Java 11的发行说明中可以看出，Oracle JDK发行说明：

在Windows和macOS中，安装早期版本中的JDK可以选择安装JRE。在JDK 11中，这不再是一个选项。在此版本中，不再提供JRE或Server JRE。仅提供JDK。用户可以使用jlink创建较小的自定义运行时。

但是随后我可以找到很多类似的讨论：

• Java 9 JRE在哪里？

• 从OpenJDK Windows创建Jre

• 为什么Java 11 JRE不随JDK一起安装，而Java 11 JRE的下载在哪里？
• 有openjdk-11-jre吗？

是这种情况，并且从Java 11开始就无法直接下载JRE ？还是在Oracle和OpenJDK之间混合实现？还是上述讨论引起误解？

编辑：我不需要下载jre，我可以通过jlink创建它或使用已经可用的解决方案，我的问题更多是理论上的。

在回答这个问题后，我在 Github 上发布了 Java 9 模块教程 + 示例以及如何为未来用户运行：

我有以下非常简单的结构：

src 
?   module-info.java
? 
????moduleA
    ????pack1
            Main.java

module-info.java :

module moduleA {

}

Main.java：

package moduleA.pack1;
public class Main{

 public static void main(String[] args){
   System.out.println("Hello Java 11");
 }
}

我正在尝试编译然后运行这个非常简单的模块化 java 应用程序。

所以从我运行的 cmd 开始：

编译

javac --module-source-path src -d out -m moduleA

跑

java  --module-path out -m moduleA/pack1.Main

从 IntelliJ 开始，它的作用就像魅力一样，我不知道它背后有什么魔力。

我做错了什么？