异常教程

Java 9 模块系统（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在 Java 的发展史上，Java 9 模块系统（Project Jigsaw）是一个具有里程碑意义的版本。它首次引入了模块化编程的概念，通过将代码组织成独立的模块（Modules），解决了传统 Java 项目中包与类的“无序扩张”问题。对于编程初学者和中级开发者而言，理解这一系统不仅能提升代码的可维护性，还能为后续学习更复杂的架构设计打下基础。本文将从零开始，通过案例和比喻，逐步解析 Java 9 模块系统的原理与实践。

模块化的意义：为什么需要模块系统？

想象一个图书馆，如果书籍随意堆放在一个大房间里，读者很难快速找到所需资料。类似地，在 Java 项目中，随着代码规模增长，包与类的依赖关系会变得复杂，导致维护成本激增。Java 9 模块系统的诞生，正是为了解决这一问题。

模块系统的核心目标是：

  1. 明确依赖关系：每个模块只能访问显式声明的依赖模块，避免隐式依赖导致的兼容性风险。
  2. 提升安全性：通过接口隔离，限制外部对模块内部类的访问，减少潜在漏洞。
  3. 优化性能：模块化编译和运行时优化，减少冗余类的加载，加速程序启动。

例如，假设有一个电商系统，其核心模块（如订单模块）和支付模块需要解耦。通过模块化设计，订单模块只需声明对支付模块的依赖，而无需暴露内部实现细节，从而降低耦合度。

模块系统的核心概念

1. 模块声明：从 module-info.java 开始

每个模块需要一个名为 module-info.java 的描述文件，用于定义模块的名称、依赖关系、导出的包等。

module com.example.calculator {  
    requires java.base; // 引用基础模块  
    exports com.example.calculator.api; // 导出公共接口包  
}
  • module 关键字：声明模块的名称，格式为 module <模块名> { ... }。
  • requires：声明当前模块依赖的其他模块（如 java.base 是 Java 核心模块）。
  • exports：将模块内部的包对外公开，允许其他模块访问。

2. 包与类的访问控制

模块系统通过 exports 和 opens 关键字控制包的可见性：

  • exports：允许其他模块访问包中的公共类（即 public 类）。
  • opens：进一步开放包，允许反射访问其非公共成员（如私有方法）。

例如，假设一个模块导出 com.example.math 包，其他模块只能使用其 public 类，而无法直接访问内部私有类。

3. 依赖传递与模块路径

模块之间的依赖关系分为两种：

  • 显式依赖：通过 requires 声明。
  • 传递依赖：如果模块 A 依赖模块 B，而模块 B 依赖模块 C，则模块 A 会间接依赖模块 C。

运行时，所有模块需通过 模块路径（module path）加载，而非传统的类路径（classpath）。

模块系统的核心语法与案例

案例 1：创建一个计算器模块

步骤 1：定义模块结构

calculator-module/  
├── module-info.java  
└── src/  
    └── com.example.calculator/  
        ├── Calculator.java  
        └── api/  
            └── ICalculator.java

步骤 2：编写 module-info.java

module com.example.calculator {  
    exports com.example.calculator.api; // 导出接口包  
    requires java.base; // 引用基础模块  
}

步骤 3：实现接口与类

// ICalculator.java（接口）  
package com.example.calculator.api;  
public interface ICalculator {  
    int add(int a, int b);  
}  

// Calculator.java（实现类）  
package com.example.calculator;  
public class Calculator implements ICalculator {  
    public int add(int a, int b) {  
        return a + b;  
    }  
}

步骤 4：使用模块

// 其他模块中的代码  
import com.example.calculator.api.ICalculator;  
public class Main {  
    public static void main(String[] args) {  
        ICalculator calc = new Calculator(); // 需要模块间依赖  
        System.out.println(calc.add(3, 5)); // 输出 8  
    }  
}

案例 2：模块间的依赖管理

假设有一个 user-management 模块依赖 database 模块：

// user-management 模块的 module-info.java  
module user.management {  
    requires database; // 显式声明依赖  
    exports user.management.api;  
}  

// database 模块的 module-info.java  
module database {  
    exports database.core;  
}

此时，user-management 可以访问 database.core 包中的公共类。

服务配置：模块化的动态扩展

模块系统通过 uses 和 provides 关键字实现服务配置，类似于 Java 的 SPI（Service Provider Interface）。

案例：日志服务的模块化设计

步骤 1：定义服务接口

// 日志接口模块 log.api  
module log.api {  
    exports log.api;  
}  

// LogService.java  
package log.api;  
public interface LogService {  
    void log(String message);  
}

步骤 2：实现服务提供者

// 日志实现模块 log.impl  
module log.impl {  
    requires log.api; // 依赖接口模块  
    provides log.api.LogService with ConsoleLogService; // 声明实现类  
}  

// ConsoleLogService.java  
package log.impl;  
public class ConsoleLogService implements LogService {  
    public void log(String message) {  
        System.out.println("LOG: " + message);  
    }  
}

步骤 3：消费服务

// 使用模块 consumer  
module consumer {  
    requires log.api; // 仅依赖接口模块  
    uses log.api.LogService; // 发现服务提供者  
}  

// Main.java  
public class Main {  
    public static void main(String[] args) {  
        ServiceLoader<LogService> loader = ServiceLoader.load(LogService.class);  
        for (LogService service : loader) {  
            service.log("Hello, Module System!"); // 输出 "LOG: Hello, Module System!"  
        }  
    }  
}

迁移策略：从非模块化到模块化的过渡

对于已有的 Java 项目，迁移到模块化系统需要以下步骤：

1. 自动模块的使用

对于未明确声明模块的 JAR 包，Java 9 会将其视为自动模块。例如，Spring Boot 的 JAR 可以通过以下方式引用：

module myapp {  
    requires spring.boot.autoconfigure; // 自动模块的名称由 JAR 文件名推导  
}

2. 使用工具 jdeps 分析依赖

通过命令行工具 jdeps，可以分析类文件的依赖关系，辅助生成模块描述文件：

jdeps --generate-module-info . myapp.jar

3. 分阶段迁移

建议采用分模块迁移策略：

  1. 先将核心模块声明为独立模块。
  2. 逐步迁移依赖模块，并修正显式依赖关系。
  3. 最后移除所有非模块化代码。

最佳实践与常见问题

1. 最佳实践

  • 保持模块粒度合理：避免模块过大或过小，通常一个模块对应一个业务功能。
  • 优先使用 exports 而非 opens：除非需要反射访问，否则不开放包的非公共成员。
  • 模块名遵循包命名规范：如 com.example.module-name。

2. 常见问题

Q：模块化后，为什么某些类无法访问？
A：检查模块的 exports 声明是否包含相关包，或依赖模块是否正确声明。

Q：如何处理第三方库的模块化兼容性？
A：使用自动模块或联系库作者提供模块化版本。

结论

Java 9 模块系统通过模块化设计，为开发者提供了更清晰的代码组织方式和更安全的依赖管理机制。对于初学者，建议从简单的模块声明开始，逐步实践依赖管理和服务配置；中级开发者则可通过分析现有项目，制定分阶段的模块化迁移计划。随着 Java 版本的迭代（如 Java 11 强化了模块功能），模块化将成为构建大型企业级应用的基石。

掌握这一系统，不仅能提升代码质量，更能帮助开发者在复杂项目中游刃有余地应对技术挑战。

最新发布

查看更多文章