Java模块化系统（Jigsaw/JPMS）：解决类路径地狱与构建可维护应用

Java模块化系统（Jigsaw/JPMS）：摆脱类路径地狱，构建可维护的应用

大家好，今天我们要深入探讨Java模块化系统，也就是Project Jigsaw，在Java 9中正式引入的JPMS。这个系统旨在解决长期困扰Java开发者的类路径地狱问题，并提供更强大的构建和维护大型应用的能力。

1. 类路径地狱：历史的痛点

在JPMS出现之前，Java一直依赖类路径（Classpath）来查找和加载类。这种机制简单直接，但随着项目规模的增长，它的缺陷也暴露无遗，我们称之为“类路径地狱”。

• 依赖管理困难： 类路径依赖于JAR文件顺序，顺序错误可能导致运行时错误，难以调试。
• 隐藏的依赖： 应用可能依赖于类路径中某个JAR提供的类，但没有显式声明，导致依赖关系不清晰。
• 版本冲突： 类路径中存在多个版本的同一个库，导致不可预测的行为，例如NoSuchMethodError或者ClassNotFoundException。
• 全局可见性： 所有类都对所有其他类可见，导致内部实现细节暴露，封装性差。
• JAR地狱： 大型应用往往依赖大量的JAR文件，类路径变得非常庞大，启动时间长，资源占用高。

为了更直观地理解，我们用一个简单的例子说明版本冲突的问题。假设项目依赖两个JAR包：library-A.jar 和 library-B.jar。

• library-A.jar 依赖 common-utils.jar 的 1.0 版本。
• library-B.jar 依赖 common-utils.jar 的 2.0 版本。

如果类路径中 common-utils.jar 的 1.0 版本在 library-B.jar 之前，library-B.jar 可能会出错，反之亦然。这种不确定性使得构建和维护大型应用变得异常困难。

2. JPMS：模块化的救赎

Java模块化系统（JPMS）通过引入模块的概念，从根本上解决了类路径地狱的问题。模块是一个命名的、自描述的代码和数据集合。它显式声明自己的依赖关系，以及对外暴露的API。

JPMS的核心概念包括：

• 模块（Module）： 一个包含代码和资源的自包含单元，通过module-info.java描述其依赖关系和对外暴露的API。
• 模块声明（module-info.java）： 一个定义模块元数据的特殊文件，位于模块的根目录下。
• exports： 声明模块对外暴露的包，只有被exports的包才能被其他模块访问。
• requires： 声明模块依赖的其他模块。
• provides…with…： 用于服务加载机制，声明模块提供的服务接口和实现类。
• uses： 用于服务加载机制，声明模块使用的服务接口。

通过显式声明依赖关系和暴露的API，JPMS实现了更强的封装性、更好的可靠性和更强的可维护性。

3. 模块声明：module-info.java

module-info.java 是JPMS的核心，它定义了模块的元数据。下面是一个示例：

module com.example.myapp {
    requires java.sql;
    requires com.example.mylibrary;

    exports com.example.myapp.api;
    exports com.example.myapp.util;

    uses com.example.myapp.spi.MyService;
    provides com.example.myapp.spi.MyService with com.example.myapp.impl.MyServiceImpl;
}

这个模块声明做了以下事情：

• module com.example.myapp： 定义了模块的名称，必须是唯一的，通常遵循反向域名命名规范。
• requires java.sql： 声明模块依赖于java.sql模块，这是Java SE平台提供的模块。
• requires com.example.mylibrary： 声明模块依赖于名为com.example.mylibrary的自定义模块。
• exports com.example.myapp.api： 声明com.example.myapp.api包中的所有公共类型对其他模块可见。
• exports com.example.myapp.util： 声明com.example.myapp.util包中的所有公共类型对其他模块可见。
• uses com.example.myapp.spi.MyService： 声明模块使用com.example.myapp.spi.MyService接口提供的服务。
• provides com.example.myapp.spi.MyService with com.example.myapp.impl.MyServiceImpl： 声明模块提供了com.example.myapp.spi.MyService接口的实现，具体实现类是com.example.myapp.impl.MyServiceImpl。

4. 模块路径：替代类路径

JPMS引入了模块路径（Module Path）来替代类路径。模块路径是一个包含模块化JAR文件或展开模块目录的路径。编译器和运行时系统使用模块路径来查找和加载模块。

可以使用-p或--module-path选项来指定模块路径。例如：

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

这个命令告诉Java虚拟机在mods目录下查找模块，并启动名为com.example.myapp的模块，主类是com.example.myapp.Main。

5. 模块的编译和打包

要将代码编译成模块，需要使用javac命令，并指定模块路径和模块声明文件。例如：

javac -d mods --module-source-path src -m com.example.myapp src/com.example.myapp/module-info.java src/com/example/myapp/**/*.java

这个命令做了以下事情：

• -d mods： 指定编译输出目录为mods。
• --module-source-path src： 指定模块源代码目录为src。
• -m com.example.myapp： 指定模块名称为com.example.myapp。
• src/com.example.myapp/module-info.java： 指定模块声明文件。
• `src/com/example/myapp//*.java`：** 指定所有Java源文件。

编译完成后，可以使用jar命令将模块打包成模块化JAR文件。例如：

jar --create --file mods/com.example.myapp.jar --module-version 1.0 -C mods/com.example.myapp .

这个命令做了以下事情：

• --create： 创建一个新的JAR文件。
• --file mods/com.example.myapp.jar： 指定JAR文件的名称为com.example.myapp.jar，并保存在mods目录下。
• --module-version 1.0： 指定模块的版本为1.0。
• -C mods/com.example.myapp .： 将mods/com.example.myapp目录下的所有文件添加到JAR文件中。

6. 模块的类型

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

• 命名模块（Named Modules）： 包含module-info.java文件的模块，具有明确的名称和依赖关系。
• 自动模块（Automatic Modules）： 不包含module-info.java文件的JAR文件，可以通过将它们放在模块路径上来转换为自动模块。自动模块的名称是从JAR文件的名称派生的。自动模块会隐式地requires所有其他模块，并且exports所有包。
• 未命名模块（Unnamed Modules）： 位于类路径上的JAR文件或类，属于未命名模块。未命名模块会隐式地requires所有命名模块，并且exports所有包。

自动模块和未命名模块是为了向后兼容而存在的，建议尽可能使用命名模块。

7. 服务加载器（Service Loader）

JPMS提供了服务加载器机制，允许模块发现和加载服务接口的实现。服务接口和实现类都需要在module-info.java文件中声明。

• uses： 声明模块使用的服务接口。
• provides…with…： 声明模块提供的服务接口和实现类。

例如，假设我们有一个服务接口com.example.myapp.spi.MyService：

package com.example.myapp.spi;

public interface MyService {
    String doSomething();
}

和一个实现类com.example.myapp.impl.MyServiceImpl：

package com.example.myapp.impl;

import com.example.myapp.spi.MyService;

public class MyServiceImpl implements MyService {
    @Override
    public String doSomething() {
        return "Hello from MyServiceImpl!";
    }
}

模块声明如下：

module com.example.myapp {
    exports com.example.myapp.spi;
    provides com.example.myapp.spi.MyService with com.example.myapp.impl.MyServiceImpl;
}

另一个模块可以使用服务加载器来获取MyService的实现：

import com.example.myapp.spi.MyService;

import java.util.ServiceLoader;

public class Main {
    public static void main(String[] args) {
        ServiceLoader<MyService> loader = ServiceLoader.load(MyService.class);
        MyService service = loader.findFirst().orElseThrow(() -> new RuntimeException("No MyService implementation found"));
        System.out.println(service.doSomething());
    }
}

8. 从类路径到模块路径的迁移策略

将现有的Java应用迁移到模块化系统需要谨慎的规划和实施。以下是一些建议的策略：

• 自底向上： 从依赖的库开始，逐步将它们模块化。
• 分析依赖关系： 使用工具（如jdeps）分析现有代码的依赖关系，确定模块边界。
• 创建module-info.java： 为每个模块创建module-info.java文件，声明依赖关系和暴露的API。
• 使用自动模块： 对于无法立即模块化的JAR文件，可以使用自动模块作为过渡方案。
• 逐步迁移： 不要试图一次性完成所有模块的迁移，可以逐步将代码迁移到模块化系统。
• 测试： 在迁移过程中，进行充分的测试，确保应用的正常运行。

jdeps工具是JDK自带的依赖分析工具，可以用来分析类路径和模块路径上的依赖关系。例如：

jdeps --module-path mods --class-path lib/myapp.jar

这个命令会分析lib/myapp.jar的依赖关系，并输出结果。

9. JPMS的优势和局限性

JPMS带来了许多优势：

• 更强的封装性： 只有被exports的包才能被其他模块访问，隐藏内部实现细节。
• 更好的可靠性： 显式声明依赖关系，避免版本冲突和运行时错误。
• 更强的可维护性： 模块化代码更易于理解、修改和测试。
• 更小的运行时： 可以创建自定义的运行时镜像，只包含应用需要的模块，减小应用的大小和启动时间。

当然，JPMS也存在一些局限性：

• 学习曲线： 模块化概念需要一定的学习成本。
• 迁移成本： 将现有的Java应用迁移到模块化系统需要时间和精力。
• 兼容性问题： 某些旧的库可能不兼容模块化系统。

特性	类路径	模块路径
依赖管理	隐式，依赖JAR文件顺序	显式，通过requires声明
可见性	全局，所有类对所有其他类可见	模块级别，只有exports的包才可见
版本冲突	容易发生，难以解决	避免，通过模块版本控制
封装性	差，内部实现细节暴露	强，只有exports的包才对外暴露
运行时大小	大，包含所有依赖的JAR文件	小，可以创建自定义的运行时镜像，只包含需要的模块
复杂性	简单，易于理解	复杂，需要理解模块声明和模块路径
向后兼容性	好，可以运行旧的JAR文件	差，需要将旧的JAR文件转换为自动模块或未命名模块

10. 代码示例：模块化Hello World

为了更具体地说明JPMS的使用，我们创建一个简单的模块化Hello World应用。

首先，创建两个模块：com.example.hello 和 com.example.world。

com.example.hello模块：

• src/com.example.hello/module-info.java

module com.example.hello {
    requires com.example.world;
}

• src/com.example.hello/com/example/hello/Main.java

package com.example.hello;

import com.example.world.World;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, " + World.getWorld());
    }
}

com.example.world模块：

• src/com.example.world/module-info.java

module com.example.world {
    exports com.example.world;
}

• src/com.example.world/com/example/world/World.java

package com.example.world;

public class World {
    public static String getWorld() {
        return "World!";
    }
}

然后，编译和打包这两个模块：

javac -d mods --module-source-path src -m com.example.hello,com.example.world src/com.example.hello/module-info.java src/com/example/hello/**/*.java src/com.example.world/module-info.java src/com/example/world/**/*.java

jar --create --file mods/com.example.hello.jar --module-version 1.0 -C mods/com.example.hello .
jar --create --file mods/com.example.world.jar --module-version 1.0 -C mods/com.example.world .

最后，运行com.example.hello模块：

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

输出结果应该是：Hello, World!

11. 模块化的未来

JPMS代表了Java平台发展的重要一步，它解决了类路径地狱的问题，并为构建更可靠、更可维护的应用奠定了基础。随着Java生态系统的不断发展，越来越多的库和框架将支持模块化，JPMS将在未来的Java开发中扮演越来越重要的角色。虽然迁移过程可能比较复杂，但是带来的好处是长远的。

模块化转型：提升代码质量，降低维护成本

JPMS通过模块化机制解决了类路径地狱的问题，提供了更强的封装性、更好的可靠性和更强的可维护性，是现代Java应用开发的关键技术。理解和应用JPMS，有助于提升代码质量，降低维护成本，构建更健壮的应用。