如何利用Java 9+的模块化特性构建可伸缩、安全的应用 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java 9+ 模块化：构建可伸缩、安全的应用

大家好！今天我们将深入探讨 Java 9 引入的模块化系统 (Java Platform Module System, JPMS)，以及如何利用它来构建更具可伸缩性和安全性的应用程序。

1. 模块化的动机：为什么要模块化？

在 Java 9 之前，Java 应用程序通常以 JAR 包的形式组织。虽然 JAR 包提供了一种打包和部署代码的方式，但它们存在一些根本性的缺陷：

缺乏封装性： 公开的类和方法对任何代码都可见，即使这些类和方法仅供内部使用。这导致了依赖关系蔓延，使得代码难以维护和重构。
脆弱的类路径： 类路径是一个扁平的命名空间，容易出现类冲突问题。不同的 JAR 包可能包含相同名称的类，导致运行时错误。
臃肿的运行时： 即使应用程序只需要 Java SE 平台的一小部分功能，也必须部署整个 Java 运行时环境（JRE）。这浪费了资源，并增加了安全风险。

模块化旨在解决这些问题，它提供了一种更强大的方式来组织、封装和管理 Java 代码。

2. 模块化核心概念

JPMS 的核心是模块。一个模块是一个自描述的、命名化的代码和资源集合。模块通过 模块描述符 (module-info.java) 来定义其依赖关系和公开的 API。

以下是模块化的关键概念：

模块描述符 (module-info.java): 位于模块的根目录下，定义了模块的名称、依赖关系、导出的包和提供的服务。
模块名称: 模块的唯一标识符，遵循反向域名命名规范 (例如：com.example.mymodule)。
exports: 声明哪些包中的类型可以被其他模块访问。未导出的包中的类型只能在模块内部使用，实现了真正的封装。
requires: 声明模块依赖的其他模块。模块必须显式声明其依赖项，这有助于避免类路径问题。
provides…with: 声明模块提供服务的接口及其实现类。
uses: 声明模块使用的服务接口。
opens…to: 声明哪些包可以被指定的模块进行深层反射访问。

3. 创建一个简单的模块化应用程序

让我们通过一个简单的示例来了解如何创建一个模块化的应用程序。假设我们要创建一个简单的 "Hello World" 应用程序，它包含两个模块：

com.example.hello: 包含 HelloWorld 类，负责打印 "Hello, World!"。
com.example.main: 包含 Main 类，负责启动应用程序并调用 HelloWorld 类。

步骤 1: 创建模块目录结构

hello-world/
├── com.example.hello/
│   └── src/
│       └── com/
│           └── example/
│               └── hello/
│                   └── HelloWorld.java
│       └── module-info.java
├── com.example.main/
│   └── src/
│       └── com/
│           └── example/
│               └── main/
│                   └── Main.java
│       └── module-info.java

步骤 2: 编写 HelloWorld 类

// com.example.hello/src/com/example/hello/HelloWorld.java
package com.example.hello;

public class HelloWorld {
    public static void sayHello() {
        System.out.println("Hello, World!");
    }
}

步骤 3: 编写 HelloWorld 模块描述符

// com.example.hello/module-info.java
module com.example.hello {
    exports com.example.hello;
}

这个模块描述符声明 com.example.hello 模块导出了 com.example.hello 包，这意味着 HelloWorld 类可以被其他模块访问。

步骤 4: 编写 Main 类

// com.example.main/src/com/example/main/Main.java
package com.example.main;

import com.example.hello.HelloWorld;

public class Main {
    public static void main(String[] args) {
        HelloWorld.sayHello();
    }
}

步骤 5: 编写 Main 模块描述符

// com.example.main/module-info.java
module com.example.main {
    requires com.example.hello;
}

这个模块描述符声明 com.example.main 模块依赖于 com.example.hello 模块。

步骤 6: 编译模块

使用 javac 命令编译模块。我们需要指定模块路径 (-p) 和模块源路径 (--module-source-path):

javac -d mods/com.example.hello --module-source-path hello-world/ com.example.hello/src/com/example/hello/HelloWorld.java com.example.hello/module-info.java
javac -d mods/com.example.main --module-source-path hello-world/ com.example.main/src/com/example/main/Main.java com.example.main/module-info.java

这将在 mods 目录下创建 com.example.hello 和 com.example.main 模块的编译结果。

步骤 7: 打包模块 (可选)

我们可以将模块打包成 JAR 文件，以便于部署和分发。

jar --create --file mods/com.example.hello.jar -C mods/com.example.hello .
jar --create --file mods/com.example.main.jar -C mods/com.example.main .

步骤 8: 运行模块化应用程序

使用 java 命令运行模块化应用程序。我们需要指定模块路径 (-p) 和主模块 (--module):

java -p mods -m com.example.main/com.example.main.Main

这将运行 com.example.main 模块的 Main 类，并输出 "Hello, World!"。

4. 模块化带来的优势

增强的封装性: 模块化提供了强大的封装机制，可以隐藏内部实现细节，只暴露必要的 API。这有助于减少依赖关系，提高代码的可维护性和可重用性。
可靠的配置: 模块必须显式声明其依赖项，这避免了类路径问题，并确保应用程序在运行时拥有所需的依赖项。
减小的运行时大小: 模块化允许创建自定义的运行时环境，只包含应用程序所需的模块。这减少了运行时的大小，提高了性能，并降低了安全风险.通过 jlink工具可以实现这一目标。
更强的安全性: 模块化可以限制对内部类的访问，从而提高应用程序的安全性。opens...to 语句可以精确控制哪些模块可以进行反射访问。
更好的可伸缩性: 模块化有助于构建大型、复杂的应用程序，通过模块边界来管理复杂性，并支持并行开发。

5. jlink：创建自定义运行时

jlink 是一个命令行工具，用于创建自定义的 Java 运行时环境 (JRE)。它可以根据应用程序的模块依赖关系，只包含所需的模块，从而减小运行时的大小。

示例:

假设我们只想创建一个包含 java.base 和 com.example.main 模块的运行时环境。

jlink --module-path $JAVA_HOME/jmods:mods -add-modules com.example.main -output myruntime

--module-path: 指定模块路径，包含 Java 平台模块和应用程序模块。
-add-modules: 指定要包含在运行时环境中的模块。
-output: 指定输出目录。

创建完成后，myruntime 目录将包含一个自定义的 JRE，只包含 java.base 和 com.example.main 模块。

6. 服务加载器 (ServiceLoader)

模块化引入了服务加载器，它是一种查找和加载服务实现的新机制。服务是一个接口或抽象类，而服务实现是实现该接口或扩展该抽象类的类。

步骤：

定义服务接口: 定义一个接口，表示要提供的服务。
提供服务实现: 创建一个类，实现服务接口。
在模块描述符中声明提供者: 使用 provides...with 语句在模块描述符中声明服务接口及其实现类。
使用服务: 使用 ServiceLoader 类加载服务实现。

示例:

假设我们要创建一个简单的日志服务。

步骤 1: 定义服务接口

// com.example.logging/src/com/example/logging/Logger.java
package com.example.logging;

public interface Logger {
    void log(String message);
}

步骤 2: 提供服务实现

// com.example.logging.impl/src/com/example/logging/impl/SimpleLogger.java
package com.example.logging.impl;

import com.example.logging.Logger;

public class SimpleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("LOG: " + message);
    }
}

步骤 3: 在模块描述符中声明提供者

// com.example.logging.impl/module-info.java
module com.example.logging.impl {
    requires com.example.logging;
    provides com.example.logging.Logger with com.example.logging.impl.SimpleLogger;
}

步骤 4: 使用服务

// com.example.app/src/com/example/app/Main.java
package com.example.app;

import com.example.logging.Logger;
import java.util.ServiceLoader;

public class Main {
    public static void main(String[] args) {
        ServiceLoader<Logger> loader = ServiceLoader.load(Logger.class);
        Logger logger = loader.findFirst().orElseThrow(() -> new RuntimeException("No logger found"));
        logger.log("Hello, World!");
    }
}

7. 模块化和反射

默认情况下，模块化限制了反射访问。一个模块只能反射访问其自身导出的类型，或者其他模块显式导出的类型。

opens...to 语句允许一个模块打开一个包，允许指定的模块进行深层反射访问。

示例:

// module-info.java
module com.example.data {
    exports com.example.data;
    opens com.example.internal to com.example.serializer;
}

这个模块描述符声明 com.example.data 模块导出了 com.example.data 包，并打开了 com.example.internal 包，允许 com.example.serializer 模块进行深层反射访问。

8. 模块化的迁移策略

将现有的 Java 应用程序迁移到模块化需要仔细的规划和执行。以下是一些建议的迁移策略：

自底向上迁移: 从最小的、最独立的模块开始，逐步迁移到更大的模块。
使用自动模块: 自动模块是包含非模块化 JAR 文件的模块。它们可以作为迁移的过渡步骤，允许非模块化代码与模块化代码共存。
分析依赖关系: 使用工具来分析应用程序的依赖关系，并确定模块的边界。
逐步重构: 不要试图一次性将整个应用程序迁移到模块化。逐步重构代码，并逐步添加模块描述符。
持续测试: 在迁移过程中进行持续测试，以确保应用程序的正确性。

9. 常见问题和解决方案

问题	解决方案
`ClassNotFoundException`	确保模块路径正确，并且所有必需的模块都已添加到模块路径中。检查模块描述符中的 `requires` 语句。
`IllegalAccessException`	检查模块描述符中的 `exports` 和 `opens...to` 语句，确保模块具有访问所需类型的权限。
类路径和模块路径冲突	避免同时使用类路径和模块路径。如果需要使用非模块化 JAR 文件，请将它们转换为自动模块。
服务加载器无法找到服务实现	确保服务实现已添加到模块路径中，并且在模块描述符中使用 `provides...with` 语句声明了服务接口及其实现类。
反射访问被拒绝	检查模块描述符中的 `opens...to` 语句，确保允许进行反射访问。

10. 模块化实战案例：微服务架构

模块化非常适合构建微服务架构。每个微服务可以作为一个独立的模块来实现，具有自己的依赖关系和 API。模块化可以帮助你更好地组织、封装和管理微服务代码，提高开发效率和可维护性。

例如，在一个电商平台中，我们可以将不同的功能模块化为微服务，例如：

商品服务 (Product Service): 负责管理商品信息。
订单服务 (Order Service): 负责处理订单流程。
用户服务 (User Service): 负责管理用户信息。
支付服务 (Payment Service): 负责处理支付流程。

每个微服务都可以独立部署和扩展，并且可以使用不同的技术栈来实现。模块化可以确保每个微服务只依赖于其所需的模块，从而减小运行时大小，提高性能，并降低安全风险。

结论

Java 9 的模块化系统为构建可伸缩、安全、易于维护的应用程序提供了强大的工具。通过模块化，我们可以更好地组织代码，减少依赖关系，提高封装性，并创建自定义的运行时环境。虽然迁移到模块化需要一些努力，但它带来的好处是巨大的。希望今天的讲座能帮助大家更好地理解和应用 Java 模块化。

Java 9+ 模块化：构建可伸缩、安全的应用

发表回复 取消回复

发表回复取消回复