深入理解Java模块系统电子书

版权声明

献词

序言

前言

致谢

关于本书

本书读者

本书的组织方式：路线图

章节

选择适合的阅读路径

需要注意的地方

关于代码

关于Java版本

代码格式约定

模块命名约定

代码中的占位符

命令及其输出

本书论坛

更多信息

关于封面插图

第一部分 你好，模块

第 1 章 第一块拼图

1.1 什么是模块化

1.1.1 用图将软件可视化

1.1.2 设计原则的影响

1.1.3 什么是模块化

1.2 Java 9之前的模块擦除

1.3 Java 9之前的问题

1.3.1 JAR之间未言明的依赖

1.3.2 同名类的覆盖

1.3.3 同一项目不同版本间的冲突

1.3.4 复杂的类加载

1.3.5 JAR的弱封装

1.3.6 手动安全检查

1.3.7 较差的启动性能

1.3.8 死板的Java运行时环境

1.4 鸟瞰模块系统

一切皆模块

1.5 你的第一个模块

1.5.1 模块系统实战

1.5.2 非模块化项目基本不受影响

1.6 模块系统的目标

1.6.1 可靠配置：不放过一个JAR

1.6.2 强封装：控制模块内部代码的访问权限

1.6.3 自动化的安全性和改善的可维护性

1.6.4 改善的启动性能

1.6.5 可伸缩的Java平台

1.6.6 非目标

1.7 新旧技能

1.7.1 你将学到什么

1.7.2 你应该知道些什么

1.8 小结

第 2 章 模块化应用程序剖析

2.1 初识ServiceMonitor

2.2 模块化ServiceMonitor

2.3 将ServiceMonitor划分为模块

2.4 文件的目录结构布局

2.5 声明和模块描述

2.5.1 声明模块依赖

2.5.2 定义模块的公有API

2.5.3 用模块图可视化ServiceMonitor

2.6 编译和打包模块

2.7 运行ServiceMonitor

2.8 扩展模块化代码库

2.9 总结：模块系统的效果

2.9.1 模块系统能为你做什么

2.9.2 模块系统还能为你做些什么

2.9.3 允许可选依赖

2.10 小结

第 3 章 定义模块及其属性

3.1 模块：模块化应用程序的基石

3.1.1 随JDK发布的Java模块（JMOD）

3.1.2 模块化JAR：内生模块

3.1.3 模块声明：定义模块的属性

3.1.4 模块的众多类型

3.2 可读性：连接所有片段

3.2.1 实现可靠配置

3.2.2 用不可靠配置进行实验

3.3 可访问性：定义公有API

3.3.1 实现强封装

3.3.2 封装传递依赖

3.3.3 封装的小冲突

3.4 模块路径：让Java了解模块

3.4.1 模块解析：分析和验证应用程序的结构

3.4.2 模块图：展示应用程序结构

3.4.3 向图中添加模块

3.4.4 向图中添加边

3.4.5 访问性是一项持续的工程

3.5 小结

第 4 章 从源码到JAR构建模块

4.1 组织项目的目录结构

4.1.1 新提议——新约定

4.1.2 默认的目录结构

4.1.3 模块声明的位置

4.2 编译单个模块

4.2.1 编译模块代码

4.2.2 模块或非模块

4.3 编译多个模块

4.3.1 直接编译

4.3.2 模块源代码路径：将项目结构告知编译器

4.3.3 星号作为模块名称的标记

4.3.4 多模块源路径入口

4.3.5 设置初始模块

4.3.6 值得吗

4.4 编译器选项

4.5 打包模块化JAR

4.5.1 快速回顾jar工具

4.5.2 分析JAR

4.5.3 定义模块入口点

4.5.4 归档选项

4.6 小结

第 5 章 运行和调试模块化应用程序

5.1 通过JVM启动模块化应用程序

5.1.1 指定主类

5.1.2 如果初始模块并非主模块

5.1.3 向应用程序传递参数

5.2 从模块中加载资源

5.2.1 Java 9之前的资源加载

5.2.2 Java 9及以上版本的资源加载

5.2.3 跨越模块边界加载包中资源

5.3 调试模块及模块化应用程序

5.3.1 分析单个模块

5.3.2 验证模块集

5.3.3 验证模块图

5.3.4 列出可见模块及其依赖

5.3.5 在解析过程中排除模块

5.3.6 通过日志信息观察模块系统

5.4 Java虚拟机选项

5.5 小结

第二部分 改写现实世界中的项目

第 6 章 迁移到Java 9及以上版本的兼容性挑战

6.1 使用JEE模块

6.1.1 为什么JEE模块很特殊

6.1.2 人工解析JEE模块

6.1.3 JEE模块的第三方实现

6.2 转化为URLClassLoader

6.2.1 应用程序类加载器的变化

6.2.2 不再通过URLClassLoader来获得类加载器

6.2.3 寻找制造麻烦的强制类型转换

6.3 更新后的运行时镜像目录布局

6.4 选择、替换和扩展平台

6.4.1 不再支持紧凑配置

6.4.2 扩展机制被移除

6.4.3 授权标准覆盖机制被移除

6.4.4 某些启动类路径选项被移除

6.4.5 不支持Java 5编译

6.4.6 JRE版本选择被移除

6.5 一着不慎，满盘皆输

6.5.1 新的版本字符串

6.5.2 工具减少

6.5.3 琐碎的事情

6.5.4 Java 9、Java 10和Java 11中新废弃的功能

6.6 小结

第 7 章 在Java 9及以上版本中运行应用程序时会反复出现的挑战

7.1 内部API的封装

7.1.1 微观视角下的内部API

7.1.2 使用JDeps分析依赖

7.1.3 编译内部API

7.1.4 运行内部API

7.1.5 访问内部API的编译器和JVM选项

7.2 修复包分裂

7.2.1 包分裂的问题是什么

7.2.2 包分裂的影响

7.2.3 处理包分裂的多种方法

7.2.4 扩展模块：处理包分裂的最后手段

7.2.5 使用JDeps查找分裂的包

7.2.6 关于依赖版本冲突的说明

7.3 小结

第 8 章 增量模块化现有项目

8.1 为什么选择增量模块化

8.1.1 如果每个JAR都必须是模块化的……

8.1.2 让普通JAR和模块化JAR混搭

8.1.3 增量模块化的技术基础

8.2 无名模块（类路径）

8.2.1 无名模块捕获的类路径混乱

8.2.2 无名模块的模块解析

8.2.3 取决于无名模块

8.3 自动模块：模块路径上的普通JAR

8.3.1 自动模块名称：小细节，大影响

8.3.2 自动模块的模块解析

8.3.3 无条件选择自动模块

8.3.4 依赖自动模块

8.4 小结

第 9 章 迁移和模块化策略

9.1 迁移策略

9.1.1 更新准备

9.1.2 工作量评估

9.1.3 基于Java 9及以上版本持续构建

9.1.4 关于命令行选项的领悟

9.2 模块化策略

9.2.1 自下而上的模块化：如果项目的所有依赖都已模块化

9.2.2 自上而下的模块化：如果应用程序无法等待其依赖

9.2.3 由内而外的模块化：如果项目位于中间层级

9.2.4 在项目中应用这些策略

9.3 将JAR模块化

9.3.1 作为中间步骤的开放式模块

9.3.2 使用JDeps生成模块声明

9.3.3 黑客破译第三方JAR

9.3.4 发布Java 8及更老版本的模块化JAR

9.4 小结

第三部分 模块系统高级特性

第 10 章 用服务来解耦模块

10.1 探索对服务的需求

10.2 JPMS中的服务

10.2.1 使用、提供和消费服务

10.2.2 服务的模块解析

10.3 良好地设计服务

10.3.1 可以作为服务的类型

10.3.2 将工厂用作服务

10.3.3 从全局状态中隔离消费者

10.3.4 将服务、消费者和提供者组织成模块

10.3.5 使用服务打破循环依赖

10.3.6 在不同的Java版本中声明服务

10.4 使用ServiceLoader API访问服务

10.4.1 加载和访问服务

10.4.2 服务加载的特性

10.5 小结

第 11 章 完善依赖关系和API

11.1 隐式可读性：传递依赖

11.1.1 公开模块的依赖

11.1.2 传递修饰符：依赖的隐式可读性

11.1.3 何时使用隐式可读性

11.1.4 何时依赖隐式可读性

11.1.5 基于隐式可读性重构模块

11.1.6 通过合并模块来重构

11.2 可选依赖

11.2.1 可靠配置的难题

11.2.2 静态修饰符：标记可选依赖

11.2.3 可选依赖的模块解析

11.2.4 针对可选依赖编写代码

11.3 合规导出：将可访问性限制在指定的模块中

11.3.1 公开内部API

11.3.2 将包导出给模块

11.3.3 什么时候使用合规导出

11.3.4 通过命令行导出包

11.4 小结

第 12 章 模块化世界中的反射

12.1 为何exports指令不能很好地适用于反射

12.1.1 深入非模块化代码

12.1.2 使内部类型强制公有

12.1.3 合规导出导致对具体模块的耦合

12.1.4 不支持深反射

12.2 开放式包和模块：为反射而生

12.2.1 为运行时访问开放式包

12.2.2 为特定模块开放式包

12.2.3 导出包与开放式包的对比

12.2.4 开放式模块：批量反射

12.3 针对模块进行反射

12.3.1 更新模块的反射代码（或不更新）

12.3.2 使用变量句柄代替反射

12.3.3 通过反射分析模块属性

12.3.4 通过反射修改模块属性

12.3.5 转发开放式包

12.4 动态创建带有层的模块图

12.4.1 什么是层

12.4.2 分析模块层

12.4.3 创建模块层

12.5 小结

第 13 章 模块版本：可能和不可能

13.1 JPMS中缺乏版本支持

13.1.1 不支持多版本

13.1.2 不支持版本选择

13.1.3 未来会怎样

13.2 记录版本信息

13.2.1 在构建模块时记录版本

13.2.2 访问模块版本

13.3 在不同的层中运行同一个模块的多个版本

13.3.1 为什么需要一个添加额外层的启动器

13.3.2 为你的应用程序、Apache Twill和Cassandra Java Driver启动层

13.4 小结

第 14 章 通过jlink定制运行时镜像

14.1 创建自定义运行时镜像

14.1.1 jlink入门

14.1.2 镜像内容和结构

14.1.3 在运行时镜像中包含服务

14.1.4 用jlink和jdeps调整镜像大小

14.2 创建独立的应用程序镜像

14.2.1 在镜像中包含应用程序模块

14.2.2 为应用程序生成一个本地启动程序

14.2.3 安全性、性能和稳定性

14.3 生成跨操作系统的镜像

14.4 使用jlink插件优化镜像

14.4.1 jlink的插件

14.4.2 减小镜像尺寸

14.4.3 提高运行时性能

14.5 jlink选项

14.6 小结

第 15 章 完成拼图

15.1 为ServiceMonitor添加装饰

15.1.1 多样化依赖

15.1.2 降低的可见性

15.1.3 通过服务解耦

15.1.4 在运行时通过层来加载代码

15.1.5 处理对普通JAR的依赖

15.2 模块化应用程序小贴士

15.2.1 是否模块化

15.2.2 理想的模块

15.2.3 注意模块声明

15.2.4 更改模块声明可能破坏代码

15.3 技术前景

15.3.1 Maven、Gradle以及其他构建工具

15.3.2 OSGi

15.3.3 微服务

15.4 关于模块化生态系统的思考

15.5 小结

附录 A 类路径回顾

A.1 使用类路径加载应用程序JAR

A.2 Java 9以来的类路径

附录 B 反射API的高级介绍

B.1 基本的类型和方法

B.2 通过setAccessible强行调用API

B.3 将注解用于反射代码

附录 C 通过统一日志观察JVM

C.1 什么是统一日志

C.2 定义应该显示哪些消息

C.3 定义消息输出位置

C.4 定义消息包含哪些内容

C.5 配置整个日志管道

附录 D 利用JDeps分析项目的依赖

D.1 认识JDeps

D.2 在分析结果中包含依赖

D.3 配置JDeps的输出

D.4 深入探寻项目的依赖

D.5 JDeps理解模块

附录 E 通过多发行版JAR支持多个Java版本

E.1 创建多发行版JAR

E.2 多发行版JAR的内部工作机制

E.3 使用建议

E.3.1 组织源代码

E.3.2 组织字节码

E.3.3 何时使用多发行版JAR

作者简介

看完了