Java 9 模块系统（完整指南）

Java 9 模块系统：让代码更清晰、更安全

在 Java 8 发布之后，Java 社区迎来了一个重要的里程碑——Java 9。虽然很多人关注的是新语法或性能优化，但真正改变 Java 开发方式的，其实是 Java 9 模块系统 的引入。它像是为庞大的 Java 生态系统安装了一套“权限门禁”和“责任划分”机制，让项目结构更清晰、依赖关系更可控。

对于初学者来说，这听起来可能有些抽象。但别担心，我们一步步来。想象一下你正在管理一个大型图书馆。过去，所有书籍都堆在同一个大房间里，你找不到某本特定的书，还可能不小心拿错了别人正在用的资料。而模块系统就像是给每本书都分配一个专属书架，只有明确授权的人才能访问。这就是 Java 9 模块系统的核心思想：封装、隔离、显式依赖。

模块是什么？它解决了什么问题？

在 Java 9 之前，Java 应用的依赖管理依赖于类路径（classpath），所有类库都放在一个目录下，JVM 会把它们全部加载进来。这带来几个问题：

• 类路径混乱：项目依赖过多时，容易出现类冲突或版本不一致。
• 无法隐藏内部实现：公共 API 之外的代码依然可以被外部调用，破坏封装性。
• 启动慢：JVM 需要扫描整个类路径，即使你根本没用到某些库。

Java 9 模块系统正是为了解决这些问题而生。它允许你将代码划分为独立的模块，每个模块声明自己提供的服务、依赖的其他模块，以及对外暴露的接口。就像一个公司里的部门，只对外公布必要的接口，内部流程对外部是透明的。

创建一个基本模块：module-info.java 文件

每个模块的起点是 module-info.java 文件。它是一个特殊的 Java 文件，用来定义模块的元信息。这个文件必须放在模块的根目录下，不能包含任何类或方法。

// module-info.java
// 定义一个名为 com.example.mymodule 的模块
// 它对外公开了 com.example.mymodule.service 包
// 它依赖于 java.base 模块（Java 核心库）
// 它使用了 java.desktop 模块（图形界面支持）

module com.example.mymodule {
    // 声明本模块公开的包，外部才能访问
    exports com.example.mymodule.service;

    // 声明本模块依赖的其他模块
    requires java.base;
    requires java.desktop;
}

💡 注释说明：

• module 关键字定义模块名称，建议使用反向域名格式（如 com.example.project）
• exports 指定哪些包可以被其他模块访问，未导出的包默认不可见
• requires 声明依赖的模块，必须明确声明，否则编译会失败
• requires transitive 用于传递依赖，比如你的模块 A 依赖 B，B 又依赖 C，那么 A 会“自动”获得对 C 的访问权

模块间的依赖与访问控制

让我们来一个实际例子。假设你有两个模块：com.example.core 和 com.example.app。

模块 core（核心模块）

// com/example/core/Calculator.java
// 核心计算类，仅提供加法功能

package com.example.core;

public class Calculator {
    // 提供加法方法
    public int add(int a, int b) {
        return a + b;
    }
}

// module-info.java
// 核心模块的配置文件

module com.example.core {
    // 只导出 Calculator 所在的包
    exports com.example.core;
}

模块 app（应用模块）

// com/example/app/Main.java
// 应用入口，使用核心模块的 Calculator

package com.example.app;

import com.example.core.Calculator; // 引入核心模块的类

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(5, 3);
        System.out.println("计算结果：" + result); // 输出：计算结果：8
    }
}

// module-info.java
// 应用模块依赖核心模块

module com.example.app {
    // 依赖核心模块
    requires com.example.core;

    // 公开本模块的主类
    exports com.example.app;
}

✅ 编译与运行命令（在模块根目录下执行）：

# 编译模块
javac --module-path . -d out com/example/core/Calculator.java
javac --module-path . -d out com/example/app/Main.java

# 运行应用
java --module-path out -m com.example.app/com.example.app.Main

⚠️ 注意：--module-path 指定了模块的搜索路径，-m 后跟模块名/主类名，必须和 module-info.java 中定义的模块名一致。

模块的封装性：private 与 exports 的配合

模块系统最强大的功能之一，是它能真正实现“封装”。我们来看一个反例：

// com/example/core/Utils.java
// 工具类，内部使用，不应被外部模块访问

package com.example.core;

public class Utils {
    public static void log(String msg) {
        System.out.println("[LOG] " + msg);
    }
}

如果 Utils.java 没有被 exports，那么即使你在 com.example.app 中写 import com.example.core.Utils;，编译也会失败。

这正是模块系统带来的安全提升：你只能访问你明确被允许的包。就像你不能随便进入公司财务室，除非你有权限。

表格：模块依赖关系与访问权限对照

✅ 建议：永远只 exports 必要的包，避免暴露内部实现。

模块的默认行为与兼容性

Java 9 模块系统不是强制性的。如果你没有 module-info.java，Java 仍然以“自动模块”（automatic module）的方式运行。也就是说，你依然可以使用原有的类路径，但模块系统会自动为每个 JAR 文件创建一个模块名。

比如，你有一个 commons-lang3-3.12.0.jar，它会被自动命名为 org.apache.commons.lang3，并默认导出所有包。这种兼容性设计让旧项目可以平滑升级。

但请注意：自动模块的封装性较弱，所有包都默认可访问。所以建议在新项目中显式定义模块，以获得最佳实践。

实际开发中的最佳实践

1. 使用模块名命名规范：建议使用 com.yourcompany.projectname 格式，避免冲突。
2. 只导出必要的包：不要为了方便而 exports *，这会破坏封装。
3. 明确声明依赖：不要依赖“默认可见”，所有依赖必须用 requires 显式声明。
4. 使用模块路径而非类路径：从 Java 9 开始，推荐使用 --module-path，避免类路径污染。
5. 结合 Maven/Gradle 使用：现代构建工具已支持模块系统，可在 pom.xml 或 build.gradle 中配置模块信息。

总结：模块系统带来的改变

Java 9 模块系统不是一次“功能更新”，而是一次“架构革命”。它让 Java 项目从“大杂烩”走向“责任分明”。对于初学者，它教会你如何设计清晰的模块边界；对于中级开发者，它提供了一套强大的工具来管理复杂项目。

虽然初期学习成本略高，但一旦掌握，你会惊讶于它带来的代码清晰度和维护效率。尤其在微服务、插件化系统中，模块系统的优势更加明显。

未来，Java 的模块化能力会持续增强。现在正是掌握它的好时机。不要等到项目大了才后悔没有早做规划。

记住：代码的清晰，始于模块的边界。从今天开始，为你的 Java 项目添加 module-info.java，让代码更安全、更可维护。