Java的Module System（JPMS）：解决模块间的依赖与访问权限控制 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java Module System (JPMS) 讲座：模块化解耦与访问控制

各位来宾，大家好！今天我们来深入探讨Java Module System (JPMS)，也就是Java 9引入的模块化系统。在大型Java项目中，随着代码量的增长，依赖关系变得错综复杂，类之间的访问权限难以控制，最终导致“JAR地狱”——版本冲突、类路径问题等。JPMS旨在解决这些问题，通过模块化方式组织代码，显式声明依赖关系，并实施更严格的访问控制。

1. 模块化的动机：JAR地狱与传统类路径的局限性

在没有模块化之前，Java项目依赖于类路径（Classpath）来加载类。所有的JAR文件都像一个巨大的全局命名空间，JVM在启动时将所有类加载到同一个空间。这带来了许多问题：

隐式依赖： 类路径上的JAR文件可能包含了项目中实际并不需要的类，造成资源浪费。
版本冲突： 如果类路径上存在相同类的不同版本，JVM会随机选择一个，导致运行时错误。这就是“JAR地狱”的典型症状。
缺乏封装： 所有的public类都可以被任何其他类访问，难以控制代码的暴露程度，增加了代码被错误使用的风险。
启动时间长： JVM需要扫描整个类路径，加载所有的类，即使某些类在当前运行环境中并不需要。

2. 模块化的核心概念：Module Descriptor (module-info.java)

JPMS的核心是模块。一个模块是一个自描述的、包含代码和资源的集合。关键在于模块描述符 module-info.java，它定义了模块的名称、依赖关系以及导出的包。

module-info.java 文件必须位于模块的根目录下，并声明以下信息：

模块名称： 使用 module 关键字定义模块的唯一名称。
依赖关系 (requires)： 使用 requires 声明当前模块依赖的其他模块。
导出包 (exports)： 使用 exports 声明当前模块中哪些包需要对外暴露，允许其他模块访问。
开放包 (opens)： 使用 opens 声明当前模块中哪些包需要对外开放给反射机制访问。
服务提供者 (provides…with)： 用于声明模块提供的服务接口及其实现类，用于Service Provider Interface (SPI) 机制。
服务消费者 (uses)： 用于声明模块使用的服务接口，用于Service Provider Interface (SPI) 机制。

3. 模块声明：语法与语义

我们通过几个示例来了解 module-info.java 的具体用法。

示例1：一个简单的模块声明

假设我们有一个名为 com.example.greeting 的模块，它导出一个名为 com.example.greeting.api 的包。

// module-info.java
module com.example.greeting {
    exports com.example.greeting.api;
}

这个模块声明表示：

模块名为 com.example.greeting。
com.example.greeting.api 包中的所有 public 类和接口都可以被其他模块访问。其他包中的类默认是模块私有的，无法被外部访问。

示例2：声明依赖关系

假设 com.example.greeting 模块依赖于 com.example.logging 模块。

// module-info.java
module com.example.greeting {
    requires com.example.logging;
    exports com.example.greeting.api;
}

这个模块声明表示：

模块名为 com.example.greeting。
它依赖于 com.example.logging 模块。这意味着 com.example.greeting 模块可以访问 com.example.logging 模块导出的包中的 public 类和接口。
com.example.greeting.api 包中的所有 public 类和接口都可以被其他模块访问。

示例3：使用 requires transitive

requires transitive 表示传递依赖。如果模块A requires transitive 模块B，那么所有依赖于模块A的模块也会自动依赖于模块B。

// module-info.java
module com.example.greeting {
    requires transitive com.example.logging;
    exports com.example.greeting.api;
}

如果模块C requires com.example.greeting，那么模块C也会自动依赖于 com.example.logging。

示例4：使用 requires static

requires static 表示可选依赖。只有在运行时存在依赖模块时，才会加载和使用该模块。如果依赖模块不存在，程序仍然可以正常运行，但可能会缺少某些功能。通常用于处理平台相关的依赖。

// module-info.java
module com.example.greeting {
    requires static com.example.optional;
    exports com.example.greeting.api;
}

示例5：使用 opens for 反射

opens 声明允许其他模块通过反射访问指定的包，即使该包没有被 exports 导出。

// module-info.java
module com.example.greeting {
    opens com.example.greeting.internal;
    exports com.example.greeting.api;
}

这意味着 com.example.greeting.internal 包中的类可以通过反射访问，即使它们不是 public 的，也没有被 exports 导出。通常用于框架或库，允许用户通过反射来扩展或定制其行为。

示例6：使用 opens...to 限制反射访问

opens...to 允许将包开放给指定的模块进行反射访问。

// module-info.java
module com.example.greeting {
    opens com.example.greeting.internal to com.example.config;
    exports com.example.greeting.api;
}

只有 com.example.config 模块才能通过反射访问 com.example.greeting.internal 包。其他模块无法通过反射访问该包。

示例7：使用 provides...with 和 uses 实现SPI

假设我们有一个服务接口 com.example.spi.GreetingService 和两个实现类 com.example.spi.impl.SimpleGreetingService 和 com.example.spi.impl.FancyGreetingService。

首先，定义服务接口模块：

// module-info.java (com.example.spi)
module com.example.spi {
    exports com.example.spi;
}

然后，定义服务实现模块 com.example.spi.impl：

// module-info.java (com.example.spi.impl)
module com.example.spi.impl {
    requires com.example.spi;
    provides com.example.spi.GreetingService with com.example.spi.impl.SimpleGreetingService;
    // provides com.example.spi.GreetingService with com.example.spi.impl.FancyGreetingService; // 可以提供多个实现
}

最后，定义使用服务的模块：

// module-info.java (com.example.app)
module com.example.app {
    requires com.example.spi;
    uses com.example.spi.GreetingService;
}

在代码中使用 ServiceLoader 来加载服务实现：

import com.example.spi.GreetingService;
import java.util.ServiceLoader;

public class App {
    public static void main(String[] args) {
        ServiceLoader<GreetingService> loader = ServiceLoader.load(GreetingService.class);
        for (GreetingService service : loader) {
            System.out.println(service.greet("World"));
        }
    }
}

4. 模块的类型：显式模块、自动模块和未命名模块

JPMS定义了三种类型的模块：

显式模块 (Explicit Modules)： 包含 module-info.java 文件的模块。这是最理想的模块类型，它提供了完整的模块化功能，包括显式依赖声明和访问控制。
自动模块 (Automatic Modules)： 通过在类路径上放置一个JAR文件并使用 --module-path 或 -p 选项启动JVM来创建。JVM会自动为该JAR文件创建一个模块，模块名称从JAR文件名派生（去掉后缀，并将-替换为.）。自动模块会隐式地 requires 类路径上的所有其他模块，并 exports JAR文件中的所有包。自动模块主要用于过渡时期，方便将现有的JAR文件迁移到模块化系统。
未命名模块 (Unnamed Module)： 当代码不在任何模块中时，它会被放在一个未命名模块中。未命名模块可以访问所有的显式模块和自动模块，但显式模块和自动模块不能访问未命名模块。

5. 模块路径与类路径：差异与选择

JPMS引入了模块路径 (Module Path) 的概念，与传统的类路径 (Classpath) 相比，它提供了更强的隔离性和控制力。

特性	类路径 (Classpath)	模块路径 (Module Path)
依赖管理	隐式，基于JAR文件的顺序	显式，通过 `module-info.java` 声明
访问控制	缺乏，所有public类都可访问	严格，基于 `exports` 和 `opens` 声明
JAR文件类型	传统JAR文件	模块化JAR文件 (Modular JAR Files)
JVM启动参数	`-classpath` 或 `-cp`	`--module-path` 或 `-p`
隔离性	弱，容易出现版本冲突	强，模块之间相互隔离，避免版本冲突
适用场景	小型项目，快速原型开发	大型项目，需要更强的依赖管理和访问控制

选择类路径还是模块路径？

模块路径： 如果你的项目已经模块化，或者计划采用模块化，应该使用模块路径。
类路径： 如果你的项目是一个小型项目，或者只是需要快速原型开发，可以使用类路径。但需要注意潜在的版本冲突和缺乏封装的问题。

6. 模块化带来的好处

更强的封装性： 只有显式导出的包才能被其他模块访问，隐藏了内部实现细节，降低了代码被错误使用的风险。
更好的依赖管理： 显式声明依赖关系，避免了隐式依赖和版本冲突，提高了代码的可维护性和可重用性。
更小的运行时 footprint： JVM只需要加载实际需要的模块，减少了内存占用和启动时间。
更强的安全性： 模块化可以限制对关键类的访问，提高应用程序的安全性。

7. 模块化迁移策略：从JAR地狱到模块天堂

将现有的非模块化项目迁移到模块化系统是一个逐步的过程。以下是一些建议：

从依赖分析开始： 使用工具分析项目的依赖关系，识别出哪些JAR文件可以组成一个模块。
创建 module-info.java 文件： 为每个模块创建 module-info.java 文件，声明模块的名称、依赖关系和导出的包。
使用自动模块： 对于无法立即模块化的JAR文件，可以将其作为自动模块添加到模块路径中。
逐步模块化： 逐步将自动模块转换为显式模块，直到所有的代码都位于显式模块中。
注意兼容性： 在迁移过程中，需要确保代码与旧版本的Java兼容。可以使用条件编译或反射来处理不同版本之间的差异。

8. 模块化的局限性与挑战

尽管JPMS带来了许多好处，但也存在一些局限性和挑战：

学习曲线： 模块化需要一定的学习成本，需要理解模块的概念和语法。
迁移成本： 将现有的非模块化项目迁移到模块化系统需要时间和精力。
第三方库的兼容性： 并非所有的第三方库都已模块化，需要考虑兼容性问题。
反射的限制： 模块化对反射访问进行了限制，需要使用 opens 声明来允许反射访问。

9. 模块化的最佳实践

清晰的模块划分： 将代码划分为逻辑上相关的模块，避免模块过于庞大或过于细小。
最小化导出： 只导出必要的包，隐藏内部实现细节。
使用 requires transitive 要谨慎： 避免过度使用 requires transitive，导致不必要的依赖。
使用 opens...to 限制反射访问： 避免将包开放给所有的模块进行反射访问，提高安全性。
遵循命名规范： 使用一致的命名规范，方便模块的识别和管理。

10. 代码示例：一个简单的模块化项目

为了更直观地理解模块化，我们创建一个简单的模块化项目，包含两个模块：com.example.api 和 com.example.impl。

模块：com.example.api

// src/com.example.api/module-info.java
module com.example.api {
    exports com.example.api;
}

// src/com.example.api/com/example/api/Greeting.java
package com.example.api;

public interface Greeting {
    String greet(String name);
}

模块：com.example.impl

// src/com.example.impl/module-info.java
module com.example.impl {
    requires com.example.api;
    exports com.example.impl;
}

// src/com.example.impl/com/example/impl/SimpleGreeting.java
package com.example.impl;

import com.example.api.Greeting;

public class SimpleGreeting implements Greeting {
    @Override
    public String greet(String name) {
        return "Hello, " + name + "!";
    }
}

模块：com.example.app (使用这两个模块)

// src/com.example.app/module-info.java
module com.example.app {
    requires com.example.api;
    requires com.example.impl; // 显式依赖 com.example.impl
}

// src/com.example.app/com/example/app/Main.java
package com.example.app;

import com.example.api.Greeting;
import com.example.impl.SimpleGreeting;

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new SimpleGreeting();
        System.out.println(greeting.greet("Module World"));
    }
}

编译和运行：

创建模块目录结构：src/com.example.api, src/com.example.impl, src/com.example.app
将源代码放置到相应的目录中。
编译模块：

javac -d mods/com.example.api src/com.example.api/module-info.java src/com.example.api/com/example/api/Greeting.java
javac -d mods/com.example.impl --module-path mods/com.example.api src/com.example.impl/module-info.java src/com.example.impl/com/example/impl/SimpleGreeting.java
javac -d mods/com.example.app --module-path mods/com.example.api:mods/com.example.impl src/com.example.app/module-info.java src/com.example.app/com/example/app/Main.java

创建模块化的JAR文件：

jar --create --file=mods/com.example.api.jar --module-version=1.0 -C mods/com.example.api .
jar --create --file=mods/com.example.impl.jar --module-version=1.0 -C mods/com.example.impl .
jar --create --file=mods/com.example.app.jar --module-version=1.0 -C mods/com.example.app .

运行应用程序：

java --module-path mods -m com.example.app/com.example.app.Main

11. 总结与展望：拥抱模块化，构建更健壮的应用

Java Module System (JPMS) 为我们提供了一种强大的方式来组织和管理大型Java项目。通过显式声明依赖关系和实施更严格的访问控制，我们可以构建更健壮、更可维护、更安全的应用程序。尽管迁移到模块化系统需要一定的成本，但从长远来看，它带来的好处是巨大的。希望今天的讲座能够帮助大家更好地理解和使用JPMS，拥抱模块化，构建更美好的Java世界。

12. 结束语：模块化是趋势，理解并运用它

JPMS是Java发展的重要一步，它解决了很多传统类路径带来的问题。虽然学习曲线略陡峭，但掌握它能让你更好地构建大型Java应用，提高代码质量，简化依赖管理。拥抱模块化，是未来Java开发的趋势。

Java Module System (JPMS) 讲座：模块化解耦与访问控制

发表回复 取消回复

发表回复取消回复