深入理解Java模块系统

第 一部分 你好，模块
第　1 章 第 一块拼图　2
1．1　什么是模块化　3
1．1．1　用图将软件可视化　3
1．1．2　设计原则的影响　5
1．1．3　什么是模块化　6
1．2　Java 9之前的模块擦除　6
1．3　Java 9之前的问题　9
1．3．1　JAR之间未言明的依赖　9
1．3．2　同名类的覆盖　10
1．3．3　同一项目不同版本间的冲突　12
1．3．4　复杂的类加载　13
1．3．5　JAR的弱封装　13
1．3．6　手动安全检查　14
1．3．7　较差的启动性能　15
1．3．8　死板的Java运行时环境　15
1．4　鸟瞰模块系统　15
1．5　你的第 一个模块　17
1．5．1　模块系统实战　18
1．5．2　非模块化项目基本不受影响　21
1．6　模块系统的目标　22
1．6．1　可靠配置：不放过一个JAR　23
1．6．2　强封装：控制模块内部代码的访问权限　23
1．6．3　自动化的安全性和改善的可维护性　24
1．6．4　改善的启动性能　24
1．6．5　可伸缩的Java平台　24
1．6．6　非目标　25
1．7　新旧技能　25
1．7．1　你将学到什么　25
1．7．2　你应该知道些什么　26
1．8　小结　27
第　2 章 模块化应用程序剖析　28
2．1　初识ServiceMonitor　28
2．2　模块化ServiceMonitor　32
2．3　将ServiceMonitor划分为模块　32
2．4　文件的目录结构布局　33
2．5　声明和模块描述　34
2．5．1　声明模块依赖　36
2．5．2　定义模块的公有API　36
2．5．3　用模块图可视化ServiceMonitor　36
2．6　编译和打包模块　37
2．7　运行ServiceMonitor　39
2．8　扩展模块化代码库　39
2．9　总结：模块系统的效果　40
2．9．1　模块系统能为你做什么　40
2．9．2　模块系统还能为你做些什么　41
2．9．3　允许可选依赖　43
2．10　小结　44
第　3 章 定义模块及其属性　45
3．1　模块：模块化应用程序的基石　46
3．1．1　随JDK发布的Java模块（JMOD）　46
3．1．2　模块化JAR：内生模块　46
3．1．3　模块声明：定义模块的属性　47
3．1．4　模块的众多类型　51
3．2　可读性：连接所有片段　53
3．2．1　实现可靠配置　54
3．2．2　用不可靠配置进行实验　55
3．3　可访问性：定义公有API　60
3．3．1　实现强封装　62
3．3．2　封装传递依赖　63
3．3．3　封装的小冲突　64
3．4　模块路径：让Java了解模块　68
3．4．1　模块解析：分析和验证应用程序的结构　69
3．4．2　模块图：展示应用程序结构　71
3．4．3　向图中添加模块　73
3．4．4　向图中添加边　74
3．4．5　访问性是一项持续的工程　74
3．5　小结　75
第　4 章 从源码到JAR构建模块　76
4．1　组织项目的目录结构　76
4．1．1　新提议——新约定　77
4．1．2　默认的目录结构　77
4．1．3　模块声明的位置　78
4．2　编译单个模块　79
4．2．1　编译模块代码　79
4．2．2　模块或非模块　80
4．3　编译多个模块　82
4．3．1　直接编译　82
4．3．2　模块源代码路径：将项目结构告知编译器　83
4．3．3　星号作为模块名称的标记　84
4．3．4　多模块源路径入口　85
4．3．5　设置初始模块　85
4．3．6　值得吗　86
4．4　编译器选项　87
4．5　打包模块化JAR　88
4．5．1　快速回顾jar工具　88
4．5．2　分析JAR　89
4．5．3　定义模块入口点　89
4．5．4　归档选项　90
4．6　小结　91
第　5 章 运行和调试模块化应用程序　92
5．1　通过JVM启动模块化应用程序　92
5．1．1　指定主类　93
5．1．2　如果初始模块并非主模块　93
5．1．3　向应用程序传递参数　95
5．2　从模块中加载资源　95
5．2．1　Java 9之前的资源加载　96
5．2．2　Java 9及以上版本的资源加载　97
5．2．3　跨越模块边界加载包中资源　98
5．3　调试模块及模块化应用程序　99
5．3．1　分析单个模块　99
5．3．2　验证模块集　100
5．3．3　验证模块图　101
5．3．4　列出可见模块及其依赖　102
5．3．5　在解析过程中排除模块　104
5．3．6　通过日志信息观察模块系统　106
5．4　Java虚拟机选项　109
5．5　小结　110
第二部分　改写现实世界中的项目
第　6 章 迁移到Java 9及以上版本的兼容性挑战　112
6．1　使用JEE模块　113
6．1．1　为什么JEE模块很特殊　114
6．1．2　人工解析JEE模块　115
6．1．3　JEE 模块的第三方实现　116
6．2　转化为URLClassLoader　117
6．2．1　应用程序类加载器的变化　117
6．2．2　不再通过URLClassLoader来获得类加载器　118
6．2．3　寻找制造麻烦的强制类型转换　119
6．3　更新后的运行时镜像目录布局　119
6．4　选择、替换和扩展平台　121
6．4．1　不再支持紧凑配置　121
6．4．2　扩展机制被移除　122
6．4．3　授权标准覆盖机制被移除　122
6．4．4　某些启动类路径选项被移除　122
6．4．5　不支持Java 5编译　122
6．4．6　JRE版本选择被移除　123
6．5　一着不慎，满盘皆输　123
6．5．1　新的版本字符串　123
6．5．2　工具减少　124
6．5．3　琐碎的事情　125
6．5．4　Java 9、Java 10和Java 11中新废弃的功能　125
6．6　小结　125
第　7 章 在Java 9及以上版本中运行应用程序时会反复出现的挑战　127
7．1　内部API的封装　128
7．1．1　微观视角下的内部API　129
7．1．2　使用JDeps分析依赖　131
7．1．3　编译内部API　133
7．1．4　运行内部API　134
7．1．5　访问内部API的编译器和JVM选项　138
7．2　修复包分裂　139
7．2．1　包分裂的问题是什么　141
7．2．2　包分裂的影响　141
7．2．3　处理包分裂的多种方法　144
7．2．4　扩展模块：处理包分裂的最后手段　145
7．2．5　使用JDeps查找分裂的包　146
7．2．6　关于依赖版本冲突的说明　147
7．3　小结　147
第　8 章 增量模块化现有项目　149
8．1　为什么选择增量模块化　150
8．1．1　如果每个JAR都必须是模块化的……　150
8．1．2　让普通JAR和模块化JAR混搭　150
8．1．3　增量模块化的技术基础　151
8．2　无名模块（类路径）　152
8．2．1　无名模块捕获的类路径混乱　154
8．2．2　无名模块的模块解析　155
8．2．3　取决于无名模块　156
8．3　自动模块：模块路径上的普通JAR　158
8．3．1　自动模块名称：小细节，大影响　159
8．3．2　自动模块的模块解析　162
8．3．3　无条件选择自动模块　168
8．3．4　依赖自动模块　169
8．4　小结　170
第　9 章 迁移和模块化策略　172
9．1　迁移策略　172
9．1．1　更新准备　173
9．1．2　工作量评估　173
9．1．3　基于Java 9及以上版本持续构建　175
9．1．4　关于命令行选项的领悟　178
9．2　模块化策略　180
9．2．1　自下而上的模块化：如果项目的所有依赖都已模块化　182
9．2．2　自上而下的模块化：如果应用程序无法等待其依赖　182
9．2．3　由内而外的模块化：如果项目位于中间层级　183
9．2．4　在项目中应用这些策略　184
9．3　将JAR模块化　185
9．3．1　作为中间步骤的开放式模块　185
9．3．2　使用JDeps生成模块声明　186
9．3．3　黑客破译第三方JAR　188
9．3．4　发布Java 8及更老版本的模块化JAR　190
9．4　小结　192
第三部分　模块系统高级特性
第　10 章 用服务来解耦模块　194
10．1　探索对服务的需求　194
10．2　JPMS中的服务　196
10．2．1　使用、提供和消费服务　196
10．2．2　服务的模块解析　201
10．3　良好地设计服务　203
10．3．1　可以作为服务的类型　204
10．3．2　将工厂用作服务　204
10．3．3　从全局状态中隔离消费者　206
10．3．4　将服务、消费者和提供者组织成模块　208
10．3．5　使用服务打破循环依赖　209
10．3．6　在不同的Java版本中声明服务　211
10．4　使用ServiceLoader API访问服务　213
10．4．1　加载和访问服务　213
10．4．2　服务加载的特性　215
10．5　小结　216
第　11 章 完善依赖关系和API　218
11．1　隐式可读性：传递依赖　219
11．1．1　公开模块的依赖　219
11．1．2　传递修饰符：依赖的隐式可读性　221
11．1．3　何时使用隐式可读性　223
11．1．4　何时依赖隐式可读性　223
11．1．5　基于隐式可读性重构模块　225
11．1．6　通过合并模块来重构　228
11．2　可选依赖　229
11．2．1　可靠配置的难题　229
11．2．2　静态修饰符：标记可选依赖　230
11．2．3　可选依赖的模块解析　231
11．2．4　针对可选依赖编写代码　232
11．3　合规导出：将可访问性限制在指定的模块中　234
11．3．1　公开内部API　235
11．3．2　将包导出给模块　236
11．3．3　什么时候使用合规导出　238
11．3．4　通过命令行导出包　239
11．4　小结　240
第　12 章 模块化世界中的反射　241
12．1　为何exports指令不能很好地适用于反射　243
12．1．1　深入非模块化代码　243
12．1．2　使内部类型强制公有　243
12．1．3　合规导出导致对具体模块的耦合　244
12．1．4　不支持深反射　244
12．2　开放式包和模块：为反射而生　245
12．2．1　为运行时访问开放式包　245
12．2．2　为特定模块开放式包　246
12．2．3　导出包与开放式包的对比　247
12．2．4　开放式模块：批量反射　248
12．3　针对模块进行反射　249
12．3．1　更新模块的反射代码（或不更新）　249
12．3．2　使用变量句柄代替反射　251
12．3．3　通过反射分析模块属性　253
12．3．4　通过反射修改模块属性　255
12．3．5　转发开放式包　256
12．4　动态创建带有层的模块图　257
12．4．1　什么是层　258
12．4．2　分析模块层　260
12．4．3　创建模块层　262
12．5　小结　266
第　13 章 模块版本：可能和不可能　268
13．1　JPMS中缺乏版本支持　268
13．1．1　不支持多版本　269
13．1．2　不支持版本选择　271
13．1．3　未来会怎样　273
13．2　记录版本信息　273
13．2．1　在构建模块时记录版本　273
13．2．2　访问模块版本　274
13．3　在不同的层中运行同一个模块的多个版本　276
13．3．1　为什么需要一个添加额外层的启动器　277
13．3．2　为你的应用程序、Apache Twill 和Cassandra JavaDriver启动层　277
13．4　小结　280
第　14 章 通过jlink定制运行时镜像　281
14．1　创建自定义运行时镜像　282
14．1．1　jlink入门　282
14．1．2　镜像内容和结构　283
14．1．3　在运行时镜像中包含服务　284
14．1．4　用jlink和jdeps调整镜像大小　287
14．2　创建独立的应用程序镜像　288
14．2．1　在镜像中包含应用程序模块　289
14．2．2　为应用程序生成一个本地启动程序　292
14．2．3　安全性、性能和稳定性　293
14．3　生成跨操作系统的镜像　294
14．4　使用jlink插件优化镜像　295
14．4．1　jlink的插件　295
14．4．2　减小镜像尺寸　297
14．4．3　提高运行时性能　301
14．5　jlink选项　301
14．6　小结　302
第　15 章 完成拼图　304
15．1　为ServiceMonitor添加装饰　304
15．1．1　多样化依赖　307
15．1．2　降低的可见性　308
15．1．3　通过服务解耦　308
15．1．4　在运行时通过层来加载代码　308
15．1．5　处理对普通JAR的依赖　309
15．2　模块化应用程序小贴士　309
15．2．1　是否模块化　309
15．2．2　理想的模块　310
15．2．3　注意模块声明　314
15．2．4　更改模块声明可能破坏代码　316
15．3　技术前景　318
15．3．1　Maven、Gradle 以及其他构建工具　318
15．3．2　OSGi　320
15．3．3　微服务　323
15．4　关于模块化生态系统的思考　325
15．5　小结　325
附录A　类路径回顾　326
附录B　反射API的高级介绍　328
附录C　通过统一日志观察JVM　331
附录D　利用JDeps 分析项目的依赖　336
附录E　通过多发行版JAR支持多个Java版本　343