模块化编程的背景与价值
1.1 传统 Java 应用的挑战
在模块化系统出现之前，Java 应用面临诸多架构性问题：

JAR 地狱：类路径上存在多个版本的相同库，导致不可预知的行为

隐式依赖：所有类对类路径上的所有其他类可见，缺乏明确的依赖声明

封装性差：内部实现细节容易意外暴露给其他模块

启动性能：JVM 需要扫描整个类路径，启动时间随着应用规模增长而增加

安全风险：反射可以访问和修改任何类的私有成员，破坏了封装性

1.2 JPMS 的设计目标
Java 平台模块系统旨在解决上述问题，其主要设计目标包括：

强封装性：模块可以明确声明哪些包对外暴露，哪些内部使用

显式依赖：模块必须明确声明依赖的其他模块

可靠的配置：在编译时和运行时验证模块依赖关系

性能优化：减少内存占用，加快启动时间

可扩展性：支持大型复杂应用的开发和维护

1.3 模块化带来的好处
采用模块化架构可以带来显著的改进：

更好的架构：强制实施关注点分离和接口隔离原则

减少冲突：明确的依赖声明避免了版本冲突

改进的安全：内部实现细节被有效隐藏

优化部署：可以创建更小的运行时镜像

增强的工具支持：IDE 和构建工具可以更好地理解应用结构

模块系统核心概念
2.1 模块声明文件 (module-info.java)
每个模块都需要在根目录下定义 module-info.java 文件：

java
// 模块声明示例
module com.example.application {
// 依赖其他模块
requires java.base; // 隐式依赖，可省略
requires java.sql;
requires java.logging;
requires transitive com.example.utils; // 传递性依赖

// 可选依赖
requires static com.example.optional;

// 导出包
exports com.example.api;
exports com.example.model to com.example.persistence;

// 开放反射访问
opens com.example.internal to com.example.testframework;

// 开放所有包（谨慎使用）
open module com.example.openapp {
    // 这里不能有exports语句
}

// 提供服务实现
provides com.example.spi.ServiceInterface
    with com.example.impl.ServiceImplementation;

// 使用服务
uses com.example.spi.ServiceInterface;

}
2.2 模块描述符指令详解
java
module com.example.detailed {
// requires 指令
requires module.name; // 必需依赖
requires transitive module.name; // 传递依赖
requires static module.name; // 编译时必需，运行时可选

// exports 指令
exports package.name;          // 导出到所有模块
exports package.name to specific.module; // 导出到特定模块

// opens 指令
opens package.name;            // 开放反射访问给所有模块
opens package.name to specific.module; // 开放给特定模块

// uses 和 provides 指令
uses service.interface.Type;
provides service.interface.Type with implementation.Type;

}

模块化开发实践
3.1 创建模块化项目结构
典型的模块化项目结构：

text
project-root/
├── module-a/
│ ├── src/
│ │ └── main/
│ │ └── java/
│ │ ├── module-info.java
│ │ └── com/
│ │ └── example/
│ │ └── modulea/
│ │ └── ModuleAClass.java
│ └── build.gradle
├── module-b/
│ ├── src/
│ │ └── main/
│ │ └── java/
│ │ ├── module-info.java
│ │ └── com/
│ │ └── example/
│ │ └── moduleb/
│ │ └── ModuleBClass.java
│ └── build.gradle
└── build.gradle
3.2 编译和运行模块化应用
bash

编译模块

javac -d build/modules \
--module-source-path src/main/java \
--module com.example.application,com.example.utils

创建模块化JAR

jar --create \
--file lib/application.jar \
--main-class com.example.application.Main \
-C build/modules/com.example.application .

运行模块化应用

java --module-path lib \
--module com.example.application/com.example.application.Main

列出所有可用模块

java --list-modules

描述特定模块

java --describe-module java.base
3.3 使用 jlink 创建自定义运行时
bash

创建自定义运行时镜像

jlink --module-path $JAVA_HOME/jmods:lib \
--add-modules com.example.application,java.sql,java.logging \
--launcher myapp=com.example.application/com.example.application.Main \
--output custom-runtime \
--strip-debug \
--compress=2 \
--no-header-files \
--no-man-pages

运行自定义镜像

custom-runtime/bin/myapp

模块化模式与最佳实践
4.1 模块设计原则
java
// 良好的模块设计示例
module com.example.bank.account {
requires transitive com.example.bank.domain;
requires java.money;

exports com.example.bank.account.api;
exports com.example.bank.account.spi;

provides com.example.bank.account.spi.AccountService
```
 with com.example.bank.account.internal.DefaultAccountService;
```
}

// 接口模块 - 只包含API
module com.example.bank.domain {
exports com.example.bank.domain.model;
exports com.example.bank.domain.repository;
}

// 实现模块
module com.example.bank.persistence {
requires transitive com.example.bank.domain;
requires java.sql;

provides com.example.bank.domain.repository.AccountRepository
    with com.example.bank.persistence.jdbc.JdbcAccountRepository;

}
4.2 处理常见场景
java
// 处理反射访问
module com.example.reflection.handling {
// 开放特定包给测试框架
opens com.example.internal to junit, mockito;

// 或者使用开放模块（谨慎）
open module com.example.fully.open {
    requires java.base;
    exports com.example.api; // 开放模块中仍然可以导出
}

}

// 处理自动模块（非模块化JAR）
module com.example.legacy.integration {
requires legacy.jar; // 自动模块名称基于JAR文件名
requires another.legacy.lib;
}

// 处理拆分包问题
module com.example.split.package {
requires some.module;
requires another.module;

// 如果两个模块包含相同的包，需要排除一个
excludes some.module; // 假设some.module包含冲突的包

}

迁移策略与兼容性
5.1 渐进式迁移方法
java
// 步骤1: 将现有JAR转换为自动模块
// 将my-library.jar放在模块路径上，它就成为自动模块
module com.example.migration.stage1 {
requires my.library; // 自动模块名基于JAR文件名
}

// 步骤2: 添加模块描述符但保持兼容
module com.example.migration.stage2 {
// 导出所有包以保持向后兼容
exports com.example.package1;
exports com.example.package2;

// 但开始使用模块化特性
requires transitive java.sql;
requires static optional.module;

}

// 步骤3: 完全模块化
module com.example.migration.stage3 {
requires java.sql;
requires transitive com.example.utils;

// 只导出必要的API
exports com.example.api;

// 严格控制反射访问
opens com.example.internal to com.example.testframework;

}
5.2 处理常见的迁移问题
java
// 问题1: 使用内部API
module com.example.internal.api.usage {
requires java.base;

// 解决方案: 使用--add-opens运行时参数
// 或者重构代码使用公共API

}

// 问题2: 服务加载器模式
module com.example.service.loader {
uses com.example.spi.ServiceProvider;

// 传统的ServiceLoader使用仍然有效
// 但现在可以在模块描述符中声明

}

// 问题3: 反射访问
module com.example.reflection.access {
// 需要显式开放包
opens com.example.reflection to reflecting.module;

// 或者使用开放模块

}

工具支持与开发环境
6.1 Maven 模块化配置
xml

4.0.0
com.example
my-module
1.0.0
jar

org.apache.maven.plugins
maven-compiler-plugin
3.8.1

11

--module-path
${project.build.directory}/modules

org.apache.maven.plugins
maven-jar-plugin
3.2.0

com.example.Main
```
 <dependency>
     <groupId>com.example</groupId>
     <artifactId>other-module</artifactId>
     <version>1.0.0</version>
 </dependency>
```
6.2 Gradle 模块化配置
gradle
// build.gradle 模块化配置
plugins {
id 'java'
id 'application'
}

repositories {
mavenCentral()
}

dependencies {
implementation 'com.example:other-module:1.0.0'
}

java {
modularity.inferModulePath = true
}

compileJava {
options.compilerArgs += [
'--module-path', classpath.asPath,
'--add-modules', 'java.sql,java.logging'
]
classpath = files()
}

run {
moduleOptions {
addModules = ['java.sql', 'java.logging']
}
}

application {
mainModule = 'com.example.application'
mainClass = 'com.example.application.Main'
}

高级特性与模式
7.1 服务绑定与查找
java
// 服务接口定义
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.impl.DefaultMyService;

}

// 服务使用者模块
module com.example.service.consumer {
requires com.example.service.api;

uses com.example.service.spi.MyService;

}

// 服务使用代码
public class ServiceUser {
public void useService() {
ServiceLoader loader = ServiceLoader.load(MyService.class);
Optional service = loader.findFirst();
service.ifPresent(MyService::doWork);
}
}
7.2 模块层与配置
java
// 创建模块层
ModuleLayer.boot() // 引导层
.defineModulesWithOneLoader(configuration, parentLoader);

// 自定义模块层配置
ModuleFinder finder = ModuleFinder.of(path1, path2);
ModuleLayer parent = ModuleLayer.boot();

Configuration config = parent.configuration()
.resolve(finder, ModuleFinder.of(), Set.of("my.module"));

ClassLoader scl = ClassLoader.getSystemClassLoader();
ModuleLayer layer = parent.defineModulesWithOneLoader(config, scl);

// 在层中查找模块
Optional module = layer.findModule("my.module");
module.ifPresent(m -> {
// 使用模块
});

性能优化与安全
8.1 启动性能优化
bash
使用类数据共享(CDS)
java -Xshare:dump -XX:SharedArchiveFile=app.jsa \
--module-path lib --module com.example.app

java -Xshare:on -XX:SharedArchiveFile=app.jsa \
--module-path lib --module com.example.app

使用AOT编译

jaotc --output libHelloWorld.so \
--module java.base \
--module-path mods/helloworld.jar \
com.example.helloworld.Main
8.2 安全增强
java
module com.example.secure.app {
// 最小权限原则：只requires必要的模块
requires java.base;
requires java.sql;

// 严格控制导出
exports com.example.api;

// 严格控制反射访问
opens com.example.internal to security.framework;

// 使用SecurityManager
requires java.security;

}

测试与调试
9.1 模块化测试策略
java
// 测试模块声明
open module com.example.test {
requires com.example.application;
requires org.junit.jupiter.api;
requires org.mockito;

// 开放测试访问
opens com.example to org.junit.platform.commons;
}

// 测试类
public class ModuleTest {

@Test
public void testModuleAccess() {
    Module module = getClass().getModule();
    assertTrue(module.isNamed());
    assertEquals("com.example.test", module.getName());
}

@Test
public void testReflectiveAccess() {
    // 测试需要反射访问的代码
    assertDoesNotThrow(() -> {
        Class<?> clazz = Class.forName("com.example.internal.InternalClass");
        Constructor<?> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        Object instance = constructor.newInstance();
    });
}

}
9.2 调试模块系统问题
bash

启用模块系统调试信息

java --module-path lib \
--module com.example.application \
-Xlog:modules=debug

检查模块解析问题

java --module-path lib \
--module com.example.application \
--show-module-resolution

诊断类加载问题

java --module-path lib \
--module com.example.application \
-verbose:class

最佳实践总结
10.1 模块设计准则
java
// 1. 保持模块小而专注
module com.example.focused.module {
requires transitive java.sql;
exports com.example.focused.api;
}

// 2. 使用接口模块分离API和实现
module com.example.api {
exports com.example.api;
}

module com.example.impl {
requires transitive com.example.api;
provides com.example.api.MyService with com.example.impl.DefaultService;
}

// 3. 谨慎使用传递性依赖
module com.example.careful.dependencies {
requires java.logging; // 直接依赖
requires transitive com.example.utils; // 只有确实需要传递时才使用
}

// 4. 合理使用开放访问
module com.example.selective.openness {
opens com.example.internal to specific.framework;
// 而不是完全开放模块
}
10.2 迁移和兼容性建议
java
// 渐进式迁移策略
module com.example.gradual.migration {
// 第一阶段：成为命名模块但保持兼容
exports com.example.package1;
exports com.example.package2;

// 第二阶段：开始使用模块特性
requires transitive important.dependency;
requires static optional.dependency;

// 第三阶段：完全模块化
opens com.example.internal to testing.framework;
provides com.example.spi.Service with com.example.impl.ServiceImpl;

}

总结
Java 平台模块系统（JPMS）为 Java 应用程序提供了强大的模块化支持，解决了长期存在的架构性问题。通过强封装性、显式依赖声明和可靠的配置验证，JPMS 帮助开发者构建更加健壮、安全和可维护的应用系统。

在实际应用中，建议采用渐进式的迁移策略，从自动模块开始，逐步添加模块描述符，最终实现完全模块化。重点关注模块边界的合理划分、依赖管理的严谨性以及反射访问的控制。

随着 Java 生态系统的不断发展，模块化已经成为现代 Java 应用开发的重要基础。掌握 JPMS 不仅能够改善现有应用的质量，更能为未来的技术演进和云原生部署奠定坚实基础。

Java 模块化系统（JPMS）技术详解与实践指南

编译模块

创建模块化JAR

运行模块化应用

列出所有可用模块

描述特定模块

创建自定义运行时镜像

运行自定义镜像

使用类数据共享(CDS)

使用AOT编译

启用模块系统调试信息

检查模块解析问题

诊断类加载问题

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Java 模块化系统（JPMS）技术详解与实践指南

编译模块

创建模块化JAR

运行模块化应用

列出所有可用模块

描述特定模块

创建自定义运行时镜像

运行自定义镜像

使用类数据共享(CDS)

使用AOT编译

启用模块系统调试信息

检查模块解析问题

诊断类加载问题

热门文章

最新文章

相关课程

相关电子书