java模块化学习_Java9模块化学习

1. 什么是模块化

本质上，模块化就是将系统分解成独立且相互连接的模块的行为。java9模块除了包含代码外，一个重要特征是增加了描述模块的文件：module-info.java

Q：为什么这么做？-- 减少复杂性

Project Jigsaw

Jigsaw 项目从2008就开始对JDk模块化进行探索，2014年开始进行设计和实现。

2. 模块化JDK

JDK由90个左右的平台模块组成，每个模块都是一个定义好的功能块，下图显示了部分模块的子集以及依赖关系：

image.png

顶部的两个重要模块：java.se.ee,java.se,主要用于对其他模块进行逻辑分组，属于聚合器模块。

每个模块都隐式依赖于java.base,因为该模块公开了java.lang, java.util之类的包。

模块之间依赖关系没有循环，java模块系统不允许编译时存在模块循环依赖。

列出所有JDK模块: java --list-modules

查看模块定义：java --describe-module java.rmi

3.模块如何定义

模块描述文件module-info.java：

module com.test{// 模块名称

requires java.sql; //依赖java.sql模块，普通依赖

requires transitive java.xml; //依赖java.xml,可传递依赖

exports com.my.test1; //导出com.my.test1包到其他模块

exports com.my.test2 to xx.xx.xx; //限制导出，导出com.my.test2到指定模块

}

可读性：模块A依赖模块B，意味着对模块B可读，也就是可以访问模块B导出包中的类型。普通依赖可读性是不可传递的。

可访问性：public、protected、private等访问修饰符的可访问性规则依旧适用。

4.模块Demo

单个模块

创建模块

编译

mkdir -p mods/helloworld

javac -d mods/helloworld helloworld/src/helloworld/module-info.java helloworld/src/helloworld/com/module/helloworld/HelloWorld.java

打包

mkdir mlib

方式1：jar -cfe mlib/helloworld.jar com.module.helloworld.HelloWorld -C mods/helloworld .

方式2：jar --create --file=mlib/com.greetings.jar --main-class=com.module.helloworld.HelloWorld -C mods/helloworld .

运行

1.以编译后的文件运行模块:

java --module-path mods --module helloworld/com.module.helloworld.HelloWorld

2.以模块化jar包运行模块:

java -p mlib -m helloworld

多个模块

模块间的引用

用Maven如何配置多个模块

1.为每个模块添加maven依赖，maven只是配置模块路径。

2.pom文件中配置编译器插件为java9或以上

org.apache.maven.plugins

maven-compiler-plugin

3.7.0

10

10

3.给每个模块添加module-info.java，并将依赖项作为requires语句添加。

模块定义限制

模块解析是一个递归的过程，从根模块开始解析->requires/requires transitive所需的模块->循环直到没有其他任何依赖项。

模块名称必须唯一

Java模块系统不支持编译期循环依赖

只有一个模块可以导出一个给定的包

模块不能定义版本，版本信息必须存储在模块之外。如Maven通过pom文件选择正确的模块版本并设置到模块路径上

image2.PNG

5. 服务

Java模块系统的服务机制可以共享公共接口，并将实现代码强封装到未导出的包中，实现服务提供者和消费者的真正解耦。

module api {

exports com.calculate; //api模块导出服务接口

}

//Caltulator接口代码

public interface Calculator {

String getName();

BigDecimal calculate(BigDecimal v1, BigDecimal v2);

}

module provider1 {

requires api;

provides com.calculate.Calculator with com.provider.Sum;//该模块提供了Calculator接口的一个实现，并且不导出实现类

}

//Sum实现类代码

public class Sum implements Calculator {

......

}

module com.consumer{

requires api;

uses com.calculate.Calculator; //该模块想要消费Calculator的实现

}

消费端代码：

public static void main(String[] args) {

ServiceLoader services = ServiceLoader.load(Calculator.class);

for (Calculator cal : services) {

cal.getName();

}

}

uses子句不要求Calculator实现在编译期间可用，消费者和提供者在运行时才被绑定在一起，由此实现了消费者和提供者的完全解耦，提供了不用重新编译、打包的可扩展性

消费者使用ServiceLoader获取提供者实现对代码是有一定侵入性的，有两种改进的方式：

在api模块接口中添加一个静态工厂方法，该方法返回所有提供者实现

module api1 {

exports com.calculate; //api模块导出服务接口

uses com.calculate.Calculator; //该模块想要消费Calculator的实现

}

//api模块接口代码

public interface Calculator {

String getName();

BigDecimal calculate(BigDecimal v1, BigDecimal v2);

static Iterable getCalculator(){

return ServiceLoader.load(Calculator.class);

}

}

module com.consumer1{

requires api;

}

消费端代码：

public static void main(String[] args) {

Iterable services = Calculator.getCalculator();

}

使用开放模块和开放包，消费者通过@Inject依赖注入服务提供者类。

open module api{// 开放模块中的所有包，任何模块都可以反射访问导出、未导出的类型的私有域

exports com.api;// 未导出包在编译时依旧是不可访问的

}

module api{

exports com.api;

opens com.api;

}

6.现有代码使用Java9

将现有代码迁移到Java9可以分两步：

在Java9上构建和运行现有代码，无需模块化

Java9有一个特殊的未命名模块(unnamed module)，该模块可以读取其他所有的模块。在模块之外编译和加载的代码都在未命名模块中。

由于JDK是模块化的，对类进行了强封装，通过反射访问这些类型时，会有警告。

(java9中exports导出的公共类型，反射访问该类型的私有域是禁止的，为了保持兼容性，默认运行时访问可以通过java选项--illegal-access=值，控制，默认值为permit )

编译和运行未命名模块时，以java.se作为根模块，如果程序使用了java.se.ee下的模块，会报错。可以使用--add-modules添加相关模块。

image3.PNG

如果代码使用了已经删除的类型，改代码。可以使用JDK附带的一个工具jdeps查找在使用的已经被删除或封装的JDK类型。

将代码模块化

其实规模比较小的程序，还有比较老的系统(没有太多更新，只是维护改bug)没必要模块化。程序规模比较大而且更新比较多的话，可以考虑迁移，因为模块化是可以提高可维护性和可重用性的。

将现有代码模块化最大的问题：如何迁移第三方库，大部分第三方库都只是普通Jar文件，不是模块。

创建自动模块：将现有jar文件放到模块路径，不用改变任何内容，就可以创建一个自动模块

自动模块会导出所有包

requires transitive 所有其他已解析的模块

添加该第三方库的包到被依赖的模块描述文件中

总结

模块化的好处

模块描述文件，编译时就能检查模块所有依赖，减少运行时错误

强封装，模块需要显示的配置向其他模块导出的内容，内部实现细节完全不可见

提高可维护性

提高安全性