💡 摘要：你是否曾为JAR地狱和类路径冲突而头疼？是否想更好地组织大型代码库？是否好奇Java 9的模块化系统能带来什么好处？
别担心，Java平台模块系统（JPMS）是Java 9引入的最重要特性之一，它解决了长期存在的依赖管理和封装问题。
本文将带你从模块化的基本概念讲起，理解为什么需要模块化。然后深入module-info.java的语法，学习如何声明模块和配置依赖。
接着通过实战案例展示如何将现有项目迁移到模块化，以及如何创建多模块项目。最后探索模块化在性能、安全性和维护性方面的优势。从基础语法到高级特性，从迁移策略到最佳实践，让你全面掌握Java模块化编程。文末附常见问题和面试高频问题，助你构建更健壮的Java应用。
一、为什么需要模块化？
1. 前模块化时代的问题
JAR地狱和类路径问题：
java
// 传统类路径的问题示例
public class ClasspathIssues {
public static void main(String[] args) {
// 问题1：重复的JAR文件
// 类路径上可能有多个版本的同一库
// 比如同时有log4j-1.2.17.jar和log4j-2.14.1.jar
// 问题2：缺失依赖
// 运行时缺少必需的依赖JAR
try {
Class.forName("com.mysql.cj.jdbc.Driver");
// 如果mysql-connector-java.jar不在类路径上，会抛出ClassNotFoundException
} catch (ClassNotFoundException e) {
System.err.println("缺少数据库驱动JAR");
}
// 问题3：隐式依赖
// 应用程序可能意外访问到依赖的依赖（传递性依赖）
// 这导致脆弱的代码和意外的耦合
}
}
2. 模块化的好处
模块化带来的优势：
- ✅ 强封装性：明确控制哪些包可以被外部访问
- ✅ 可靠的配置：声明式依赖管理，避免缺失依赖
- ✅ 更好的性能：更快的启动时间和更小的内存占用
- ✅ 增强安全性：减少攻击面，限制反射访问
- ✅ 可维护性：更好的代码组织和架构清晰度
二、模块系统核心概念
1. 模块描述符（module-info.java）
基本模块声明：
java
// module-info.java - 模块描述符文件
module com.example.myapp {
// 依赖其他模块
requires java.sql;
requires java.logging;
// 导出包给其他模块使用
exports com.example.myapp.api;
exports com.example.myapp.model;
// 开放包用于反射访问（通常给框架使用）
opens com.example.myapp.internal to spring.core;
// 提供服务实现
provides com.example.myapp.spi.MyService with com.example.myapp.impl.DefaultService;
// 使用服务
uses com.example.myapp.spi.MyService;
}
2. 模块类型
系统模块 vs 应用程序模块：
bash
# 查看系统模块列表
java --list-modules
# 输出示例：
# java.base@17
# java.sql@17
# java.logging@17
# jdk.compiler@17
自动模块：为了向后兼容，非模块化的JAR可以作为自动模块使用
java
// 自动模块的名称从JAR文件名派生
// 比如：guava-31.0-jre.jar → 模块名 guava
module com.example.myapp {
requires guava; // 使用自动模块
requires commons.lang; // 自动模块名从commons-lang-3.12.0.jar派生
}
三、模块声明详解
1. requires 指令
依赖声明：
java
module com.example.myapp {
// 必需依赖
requires java.sql;
// 静态依赖（编译时需要，运行时可选）
requires static java.xml;
// 传递性依赖（依赖本模块的模块也会自动依赖这些模块）
requires transitive java.logging;
requires transitive java.net.http;
// 版本要求（可选的版本信息）
requires org.apache.commons.lang3;
}
2. exports 和 opens
包导出和开放：
java
module com.example.library {
// 导出公共API包
exports com.example.library.api;
exports com.example.library.model;
// 限定导出（只给特定模块访问）
exports com.example.library.internal to com.example.myapp;
// 开放包用于反射（运行时访问）
opens com.example.library.reflection;
// 限定开放（只给特定模块反射访问）
opens com.example.library.config to spring.core, hibernate.core;
// 开放所有包（不推荐，除非必要）
open module com.example.library {
// 这里不能再有exports/opens语句
}
}
3. provides 和 uses
服务加载机制：
java
// 服务接口（在API模块中）
module com.example.service.api {
exports com.example.service.spi;
}
// 服务提供者（在实现模块中）
module com.example.service.provider {
requires com.example.service.api;
provides com.example.service.spi.MyService with
com.example.service.provider.DefaultService,
com.example.service.provider.AdvancedService;
}
// 服务使用者（在应用模块中）
module com.example.myapp {
requires com.example.service.api;
uses com.example.service.spi.MyService;
}
四、实战：模块化迁移
1. 将传统应用迁移为模块
步骤1：分析现有依赖
bash
# 使用jdeps分析依赖
jdeps --list-deps myapp.jar
# 输出：
# java.base
# java.sql
# java.logging
# org.slf4j # 第三方依赖
步骤2：创建module-info.java
java
// module-info.java
module com.example.myapp {
// 声明JDK模块依赖
requires java.sql;
requires java.logging;
// 声明第三方依赖（作为自动模块）
requires slf4j.api;
requires commons.lang;
// 导出应用包
exports com.example.myapp;
exports com.example.myapp.model;
// 开放给反射框架
opens com.example.myapp.entity to hibernate.core;
}
步骤3：编译和运行
bash
# 编译模块
javac -d mods --module-source-path src $(find src -name "*.java")
# 运行模块化应用
java --module-path mods:libs -m com.example.myapp/com.example.myapp.Main
# 打包模块化JAR
jar --create --file myapp.jar --main-class com.example.myapp.Main -C mods/com.example.myapp .
2. 多模块项目示例
项目结构：
text
my-project/
├── api/
│ ├── src/
│ │ └── com.example.api/
│ └── module-info.java
├── impl/
│ ├── src/
│ │ └── com.example.impl/
│ └── module-info.java
├── app/
│ ├── src/
│ │ └── com.example.app/
│ └── module-info.java
└── libs/ # 第三方JAR
API模块：
java
// api/module-info.java
module com.example.api {
exports com.example.api;
exports com.example.api.spi;
}
实现模块：
java
// impl/module-info.java
module com.example.impl {
requires transitive com.example.api;
requires java.logging;
provides com.example.api.spi.MyService with com.example.impl.DefaultService;
}
应用模块：
java
// app/module-info.java
module com.example.app {
requires com.example.api;
requires com.example.impl;
uses com.example.api.spi.MyService;
}
五、高级模块化特性
1. 模块层（Module Layers）
动态模块加载：
java
public class ModuleLayerExample {
public static void main(String[] args) throws Exception {
// 创建模块层来动态加载模块
ModuleLayer bootLayer = ModuleLayer.boot();
// 配置模块查找器
Path modulesDir = Paths.get("dynamic-modules");
ModuleFinder finder = ModuleFinder.of(modulesDir);
// 创建新模块层
Configuration config = bootLayer.configuration()
.resolve(finder, ModuleFinder.of(), Set.of("com.example.plugin"));
// 创建模块层
ModuleLayer layer = bootLayer.defineModulesWithOneLoader(config, ClassLoader.getSystemClassLoader());
// 使用模块层中的模块
Optional<Module> pluginModule = layer.findModule("com.example.plugin");
pluginModule.ifPresent(module -> {
// 动态加载和使用模块
});
}
}
2. 模块修补（Module Patching）
运行时模块替换：
bash
# 使用--patch-module参数修补模块
java --patch-module java.base=patches/java.base \
--module-path mods \
-m com.example.myapp/com.example.myapp.Main
六、模块化最佳实践
1. 模块设计原则
模块化设计指南：
java
// 1. 保持模块内聚性
module com.example.userservice {
// 相关功能放在同一模块
requires java.persistence;
exports com.example.userservice;
exports com.example.userservice.model;
exports com.example.userservice.dao;
}
// 2. 避免循环依赖
// 错误示例：模块A依赖模块B，模块B又依赖模块A
// 3. 使用接口隔离
module com.example.api {
exports com.example.api;
// 不导出实现细节
}
// 4. 合理使用自动模块（过渡期）
module com.example.myapp {
requires legacy.lib; // 自动模块
}
2. 迁移策略
渐进式迁移：
- 阶段1：保持非模块化，在类路径运行
- 阶段2：添加module-info.java，使用自动模块
- 阶段3：将关键依赖转换为显式模块
- 阶段4：完全模块化，使用模块路径
七、常见问题与解决方案
1. 模块化常见错误
典型问题及解决：
java
// 问题1：模块找不到
// 错误：Module not found: java.xml
// 解决：添加 requires java.xml;
// 问题2：包不可见
// 错误：package is not visible
// 解决：在模块描述符中添加 exports 或 opens
// 问题3：服务加载失败
// 错误：ServiceLoader找不到实现
// 解决：确保提供了 provides...with 声明
// 问题4：反射访问失败
// 错误：IllegalAccessException
// 解决：添加 opens 语句开放包
2. 工具支持
模块化开发工具：
bash
# jdeps：依赖分析
jdeps --module-path mods -m com.example.myapp
# jlink：创建自定义运行时
jlink --module-path $JAVA_HOME/jmods:mods \
--add-modules com.example.myapp \
--output myruntime
# jmod：处理JMOD文件
jmod create --class-path classes mymodule.jmod
八、总结：模块化价值
1. 模块化的优势
- ✅ 更好的架构：强制性的模块边界和明确依赖
- ✅ 改进的性能：更快的类加载和更少的内存使用
- ✅ 增强的安全：强封装限制未授权访问
- ✅ 简化部署：自定义运行时和更好的依赖管理
2. 适用场景
推荐使用模块化的场景：
- 大型应用程序和框架
- 需要强封装的安全敏感应用
- 希望优化启动时间和内存使用的应用
- 需要清晰架构和依赖管理的项目
九、面试高频问题
❓1. JPMS的主要目标是什么？
答：提供强封装性、可靠的配置、更好的性能和改进的安全性，解决JAR地狱和类路径问题。
❓2. requires static 和 requires transitive 有什么区别？
答：requires static表示编译时必需但运行时可选的依赖，requires transitive表示传递性依赖。
❓3. exports 和 opens 有什么区别？
答：exports允许其他模块在编译时和运行时访问包中的公共类型，opens允许运行时反射访问（包括私有成员）。
❓4. 什么是自动模块？
答：自动模块是非模块化的传统JAR文件，被放置在模块路径时自动转换成模块，模块名从JAR文件名派生。
❓5. 如何将现有项目迁移到模块化？
答：逐步迁移：先分析依赖，添加module-info.java，使用自动模块，逐步将依赖转换为显式模块，最终完全模块化。
