4.4 Maven 与 GraalVM Native Image

文档摘要

4.4 Maven 与 GraalVM Native Image 4.4 Maven 与 GraalVM Native Image 4.4.1 GraalVM Native Image 技术概览 GraalVM Native Image 是 GraalVM 项目的核心组件之一，它能够将 Java 字节码编译成独立的可执行文件，这些可执行文件不依赖于传统的 Java 虚拟机 (JVM)。其核心优势在于：极速启动: 本地镜像无需 JVM 预热，启动时间可以缩短到毫秒级别，非常适合对启动速度敏感的场景，如 Serverless 函数、CLI 工具等。低资源消耗: 本地镜像运行时内存占用更小，CPU 利用率更高，降低了基础设施成本，提升了资源利用率。

4.4 Maven 与 GraalVM Native Image

4.4 Maven 与 GraalVM Native Image

4.4.1 GraalVM Native Image 技术概览

GraalVM Native Image 是 GraalVM 项目的核心组件之一，它能够将 Java 字节码编译成独立的可执行文件，这些可执行文件不依赖于传统的 Java 虚拟机 (JVM)。其核心优势在于：

极速启动: 本地镜像无需 JVM 预热，启动时间可以缩短到毫秒级别，非常适合对启动速度敏感的场景，如 Serverless 函数、CLI 工具等。
低资源消耗: 本地镜像运行时内存占用更小，CPU 利用率更高，降低了基础设施成本，提升了资源利用率。
增强安全性: 本地镜像减少了对 JVM 的依赖，缩小了攻击面，同时可以更容易地集成操作系统的安全特性。
简化部署: 本地镜像可以打包成单个可执行文件，无需安装 JVM，简化了部署流程，方便分发和运行。

然而，GraalVM Native Image 也存在一些限制：

闭世界假设 (Closed World Assumption): Native Image 在构建时需要分析整个应用的依赖关系，并假定运行时不会动态加载新的类或资源。这意味着反射、动态代理、类加载等动态特性需要显式配置。
构建时间较长: AOT 编译过程比传统的 JIT 编译更耗时，构建本地镜像可能需要更长的时间。
兼容性挑战: 并非所有 Java 库和框架都天然兼容 Native Image，可能需要进行适配或调整。

4.4.2 Maven 集成 GraalVM Native Image 的方式

Maven 通过插件的方式与 GraalVM Native Image 进行集成，最常用的插件是 native-image-maven-plugin。该插件简化了本地镜像的构建过程，允许开发者在 Maven 构建生命周期中无缝地生成 Native Image。

4.4.2.1 native-image-maven-plugin 插件详解

native-image-maven-plugin 插件提供了以下核心功能：

native-image:native-image 目标: 该目标负责调用 GraalVM Native Image 工具 native-image，将 Maven 项目编译成本地可执行文件。
配置参数: 插件提供了丰富的配置参数，允许开发者自定义 Native Image 构建过程，例如指定主类、镜像名称、构建参数等。
与 Maven 生命周期集成: 插件可以将 Native Image 构建过程集成到 Maven 的构建生命周期中，例如在 package 阶段之后执行。

4.4.2.2 pom.xml 配置示例

要使用 native-image-maven-plugin 插件，需要在 pom.xml 文件中添加插件配置。以下是一个基本的 pom.xml 配置示例：


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>native-image-example</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <graalvm.version>22.3.0</graalvm.version> <!-- 替换为你的 GraalVM 版本 -->
        <native-image.version>${graalvm.version}</native-image.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>info.picocli</groupId>
            <artifactId>picocli</artifactId>
            <version>4.7.0</version> <!-- 这里使用 picocli 框架作为示例，可以替换为其他依赖 -->
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.graalvm.buildtools</groupId>
                <artifactId>native-image-maven-plugin</artifactId>
                <version>${native-image.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>native-image</goal>
                        </goals>
                        <phase>package</phase> <!-- 在 package 阶段构建 Native Image -->
                    </execution>
                </executions>
                <configuration>
                    <imageName>my-native-app</imageName> <!-- 指定 Native Image 的名称 -->
                    <mainClass>com.example.Main</mainClass> <!-- 指定主类 -->
                    <!-- 可以添加更多的构建参数，例如 -Obitcode, --verbose 等 -->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.Main</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

配置详解:

<properties> 标签:
- <graalvm.version>: 定义 GraalVM 版本，需要根据实际安装的 GraalVM 版本进行替换。
- <native-image.version>: 通常与 <graalvm.version> 保持一致，用于插件版本管理。
<dependencies> 标签: 声明项目依赖，这里使用了 picocli 命令行框架作为示例。实际项目中需要根据应用的需求添加依赖。
<build> -> <plugins> -> <plugin> (native-image-maven-plugin):
- <groupId>, <artifactId>, <version>: 指定 native-image-maven-plugin 插件的信息。
- <executions> -> <execution>: 配置插件的执行时机和目标。
  - <goals> -> <goal>native-image</goal>: 指定要执行的目标为 native-image。
  - <phase>package</phase>: 将 Native Image 构建绑定到 Maven 的 package 生命周期阶段，在打包 JAR 包之后执行。
- <configuration>: 配置 native-image 目标的参数。
  - <imageName>my-native-app</imageName>: 指定生成的本地可执行文件的名称为 my-native-app。
  - <mainClass>com.example.Main</mainClass>: 指定应用的主类为 com.example.Main。
  - 其他配置参数: native-image-maven-plugin 还支持许多其他配置参数，例如：
    - <outputDirectory>: 指定 Native Image 输出目录。
    - <buildArgs>: 允许传递额外的 native-image 构建参数，例如 -Obitcode (优化级别), --verbose (详细输出), --static (静态链接), --libc=musl (使用 musl libc) 等。
    - <javaHome>: 指定 JDK 的路径，如果环境变量 JAVA_HOME 未正确设置，可以使用此参数显式指定。
    - <reflectConfigDirectories>, <resourceConfigDirectories>, <jniConfigDirectories>, <proxyConfigDirectories>: 用于指定反射、资源、JNI 和代理配置文件的目录，这些配置文件用于解决 Native Image 的闭世界假设带来的限制。
<build> -> <plugins> -> <plugin> (maven-shade-plugin):
- maven-shade-plugin 通常用于将应用的依赖打包到同一个 JAR 包中，在这里也用于确保 Native Image 构建时能够找到主类信息。虽然 Native Image 构建并不直接依赖 Shade 插件的输出 JAR，但为了保证 Maven 构建流程的完整性和清晰度，以及在某些情况下可能需要先构建可执行 JAR 再构建 Native Image 的场景，建议保留 Shade 插件配置。

4.4.3 代码实践：构建简单的 Native Image 应用

步骤 1：创建 Maven 项目

使用 Maven 命令或者 IDE 创建一个新的 Maven 项目，例如使用 Maven 命令：


mvn archetype:generate -DgroupId=com.example -DartifactId=native-image-example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

步骤 2：添加 pom.xml 配置

将上面提供的 pom.xml 配置添加到项目的 pom.xml 文件中，并根据实际情况修改 <graalvm.version>, <mainClass> 和 <imageName> 等参数。

步骤 3：编写 Java 代码

在 src/main/java/com/example 目录下创建 Main.java 文件，并编写简单的代码，例如：


package com.example;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
import picocli.CommandLine.Parameters;
import java.util.concurrent.Callable;
@Command(name = "greet", mixinStandardHelpOptions = true, version = "greet 1.0",
        description = "Greets someone.")
public class Main implements Callable<Integer> {
    @Parameters(index = "0", description = "The person to greet.")
    private String name;
    @Option(names = {"-c", "--count"}, description = "Number of greetings.")
    private int count = 1;
    public static void main(String[] args) {
        int exitCode = new CommandLine(new Main()).execute(args);
        System.exit(exitCode);
    }
    @Override
    public Integer call() throws Exception { // your business logic goes here...
        for (int i = 0; i < count; i++) {
            System.out.println("Hello, " + name + "!");
        }
        return 0;
    }
}

这个示例使用了 picocli 框架来创建一个简单的命令行应用，接收一个名字和可选的计数参数，并打印问候语。

步骤 4：构建 Native Image

在项目根目录下执行 Maven 命令：


mvn package

或者使用更具体的命令，直接执行 native-image 目标：


mvn native-image:native-image

如果一切配置正确，Maven 将会下载 native-image-maven-plugin 插件，并调用 GraalVM Native Image 工具 native-image 进行编译。编译过程可能需要一些时间，具体取决于项目的大小和复杂度。

步骤 5：运行 Native Image

构建成功后，在 target 目录下会生成本地可执行文件 my-native-app (根据 pom.xml 中的 <imageName> 配置)。可以直接运行该可执行文件：


./target/my-native-app World
./target/my-native-app Universe -c 3

你会看到应用快速启动并输出问候语。

4.4.4 Native Image 构建过程详解

Native Image 的构建过程可以概括为以下几个阶段：

流程详解:

Maven Package Phase: Maven 构建生命周期的 package 阶段，native-image-maven-plugin 插件在这一阶段被触发。插件会收集项目的依赖、编译后的字节码等信息，为后续的 Native Image 构建做准备。
Reachability Analysis (可达性分析): 这是 Native Image 构建的核心步骤。GraalVM Native Image 工具会从应用的主类开始，静态分析整个应用的调用链，找出所有在运行时可能被执行到的代码、类和资源。这个过程基于 闭世界假设，即假设运行时不会动态加载新的代码。
Closed World Assumption (闭世界假设): Native Image 的关键假设。如果应用的代码违反了闭世界假设，例如使用了反射、动态代理、类加载等动态特性，并且没有进行显式配置，那么 Reachability Analysis 可能无法正确识别所有需要的代码，导致运行时错误。
Static Analysis (静态分析): 在 Reachability Analysis 的基础上，Native Image 工具进行更深入的静态分析，例如确定对象的类型信息、方法调用关系等，为后续的 AOT 编译做准备。
Bytecode-to-Machine Code Compilation (字节码到机器码编译): GraalVM Native Image 使用 Graal 编译器将经过静态分析的代码编译成本地机器码。这个过程是 AOT 编译的核心，它将 Java 字节码直接编译成目标平台的机器码，避免了 JVM 的运行时编译和解释执行，从而提升性能。
Executable Image Generation (可执行镜像生成): 将编译后的机器码、必要的运行时库、以及静态分析确定的资源文件等打包成一个独立的可执行文件，即 Native Image。
Native Image Output (本地镜像输出): 最终生成的 Native Image 文件，可以直接在目标平台上运行，无需 JVM。
Reflection/JNI/Resources (反射/JNI/资源): 如果应用使用了反射、JNI 或需要访问资源文件，Reachability Analysis 可能会遇到困难，因为这些动态特性在静态分析时难以完全确定。
Configuration Files (配置文件): 为了解决闭世界假设带来的限制，Native Image 提供了配置文件机制，允许开发者显式声明应用使用的反射、JNI、代理以及资源信息。这些配置文件通常包括 reflection-config.json, jni-config.json, proxy-config.json, resource-config.json 等。开发者需要手动编写或使用 Agent 工具自动生成这些配置文件，并将其配置到 native-image-maven-plugin 中，以便 Native Image 工具在构建时能够正确处理这些动态特性。

4.4.5 解决 Native Image 的闭世界假设挑战

Native Image 的闭世界假设是其最大的挑战之一。为了构建成功的 Native Image 应用，开发者需要仔细处理反射、动态代理、类加载和资源访问等动态特性。

4.4.5.1 反射配置 (Reflection Configuration)

如果应用使用了反射，例如通过 Class.forName(), Method.invoke(), Field.get() 等 API 动态访问类、方法或字段，Native Image 需要在构建时知道这些反射调用的目标。否则，这些类、方法或字段可能不会被包含到 Native Image 中，导致运行时 NoSuchMethodException, NoSuchFieldException 等错误。

解决方案:

手动编写 reflection-config.json: 手动分析代码，找出所有反射调用的地方，并编写 reflection-config.json 文件，声明需要反射访问的类、方法和字段。
使用 Native Image Agent 自动生成 reflection-config.json: GraalVM 提供了 Native Image Agent 工具，可以在应用运行时动态收集反射、JNI、代理和资源访问信息，并生成相应的配置文件。使用 Agent 工具可以大大简化配置文件的编写过程。

Agent 工具使用示例:

在 Maven 项目的 pom.xml 中，添加一个 Maven Profile，用于运行 Agent 工具：


<profiles>
    <profile>
        <id>native-agent</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.0.0</version>
                    <executions>
                        <execution>
                            <id>agent</id>
                            <phase>package</phase>
                            <goals>
                                <goal>java</goal>
                            </goals>
                            <configuration>
                                <agent>native-image-agent.jar=config-output-dir=src/main/resources/META-INF/native-image</agent>
                                <mainClass>com.example.Main</mainClass> <!-- 替换为你的主类 -->
                                <!-- 传递应用的参数，以便 Agent 能够收集到运行时信息 -->
                                <arguments>
                                    <argument>World</argument>
                                </arguments>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

执行 Maven 命令，激活 native-agent Profile：


mvn package -Pnative-agent

运行上述命令后，Agent 工具会在 src/main/resources/META-INF/native-image 目录下生成 reflection-config.json, resource-config.json 等配置文件。
将生成的配置文件目录配置到 native-image-maven-plugin 中：


<configuration>
    </configuration>
        <configuration>
            <imageName>my-native-app</imageName>
            <mainClass>com.example.Main</mainClass>
            <reflectConfigDirectories>
                <reflectConfigDirectory>src/main/resources/META-INF/native-image</reflectConfigDirectory>
            </reflectConfigDirectories>
            <resourceConfigDirectories>
                <resourceConfigDirectory>src/main/resources/META-INF/native-image</resourceConfigDirectory>
            </resourceConfigDirectories>
        </configuration>
    </configuration>

4.4.5.2 资源配置 (Resource Configuration)

如果应用需要访问类路径下的资源文件，例如 properties 文件、图片文件等，Native Image 也需要在构建时知道这些资源文件，并将它们包含到 Native Image 中。

解决方案:

手动编写 resource-config.json: 手动列出需要包含的资源文件或资源文件匹配模式。
使用 Native Image Agent 自动生成 resource-config.json: 与反射配置类似，Agent 工具也可以自动收集资源访问信息，并生成 resource-config.json 文件。

4.4.5.3 JNI 配置 (JNI Configuration) 和代理配置 (Proxy Configuration)

如果应用使用了 JNI (Java Native Interface) 调用本地代码，或者使用了动态代理，也需要进行相应的配置，方法类似反射和资源配置，需要手动编写 jni-config.json, proxy-config.json 文件，或者使用 Agent 工具自动生成。

4.4.6 Maven Profile 管理 Native Image 构建

为了更好地管理 Native Image 构建，建议使用 Maven Profile 将 Native Image 构建配置与常规的 JAR 包构建配置分离。

示例 pom.xml 配置 (使用 Maven Profile):


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>native-image-example</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <graalvm.version>22.3.0</graalvm.version>
        <native-image.version>${graalvm.version}</native-image.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>info.picocli</groupId>
            <artifactId>picocli</artifactId>
            <version>4.7.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.Main</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <profiles>
        <profile>
            <id>native</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.graalvm.buildtools</groupId>
                        <artifactId>native-image-maven-plugin</artifactId>
                        <version>${native-image.version}</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>native-image</goal>
                                </goals>
                                <phase>package</phase>
                            </execution>
                        </executions>
                        <configuration>
                            <imageName>my-native-app</imageName>
                            <mainClass>com.example.Main</mainClass>
                            <reflectConfigDirectories>
                                <reflectConfigDirectory>src/main/resources/META-INF/native-image</reflectConfigDirectory>
                            </reflectConfigDirectories>
                            <resourceConfigDirectories>
                                <resourceConfigDirectory>src/main/resources/META-INF/native-image</resourceConfigDirectory>
                            </resourceConfigDirectories>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

使用 Profile 构建 Native Image:


mvn package -Pnative

优势:

清晰分离: 将 Native Image 构建配置放在 native Profile 中，与默认的 JAR 包构建配置分离，使得 pom.xml 文件结构更清晰，易于维护。
灵活控制: 可以根据需要选择是否激活 native Profile，灵活控制是否构建 Native Image。
配置复用: 可以在 Profile 中定义特定于 Native Image 构建的配置，例如构建参数、配置文件目录等，避免与默认配置冲突。

4.4.7 总结与展望

Maven 与 GraalVM Native Image 的集成，为 Java 开发者提供了一种便捷的方式来构建高性能、低资源消耗的本地应用。通过 native-image-maven-plugin 插件，开发者可以轻松地将 Native Image 构建集成到 Maven 构建生命周期中，并利用 Maven 的依赖管理和构建自动化能力。

然而，Native Image 的闭世界假设仍然是一个需要认真对待的挑战。开发者需要深入理解 Native Image 的工作原理，并仔细处理应用中的动态特性，例如反射、动态代理、类加载和资源访问。使用 Native Image Agent 工具可以大大简化配置文件的编写过程，但仍然需要开发者对应用的代码进行一定的分析和调整。

随着 GraalVM 项目的不断发展和完善，Native Image 技术也在不断成熟。未来，我们期待看到更智能化的工具和更强大的框架，能够进一步简化 Native Image 的开发和应用，使得 Java 应用在云原生和微服务领域发挥更大的作用。

总结:

GraalVM Native Image 提供了将 Java 应用编译成本地可执行文件的能力，具有极速启动、低资源消耗等优势。
Maven 通过 native-image-maven-plugin 插件与 GraalVM Native Image 集成，简化了 Native Image 的构建流程。
构建 Native Image 应用需要理解闭世界假设，并处理反射、资源等动态特性，可以使用 Native Image Agent 工具辅助配置。
Maven Profile 可以用于管理 Native Image 构建配置，实现与常规 JAR 包构建配置的清晰分离。
Native Image 技术在云原生和微服务领域具有广阔的应用前景，未来可期。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/210-maven%E9%A1%B9%E7%9B%AE%E6%9E%84%E5%BB%BA%E4%B8%8E%E7%AE%A1%E7%90%86%E6%95%99%E7%A8%8B

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流