轩辕李的博客
轩辕李
2024-05-07
目录

Spring对于原生镜像和AOT的支持

# 一、引言

# 1. 背景

在云原生时代，应用需要具备快速启动、弹性伸缩、高效资源利用等特性，以适应快速变化的业务需求和降低运营成本。

传统的 Spring 应用通常依赖于 JVM 运行时，启动时间较长，资源占用较高，这在云原生环境下显得不够高效。

容器化技术的普及进一步加速了对应用启动速度和资源效率的要求。例如，Kubernetes 等容器编排平台对应用的快速启动能力有很高的要求，以便实现快速扩容和故障恢复。

因此，如何优化 Spring 应用，使其更好地适应云原生环境，成为了一个重要的课题。

Spring Framework 作为 Java 开发领域最流行的框架之一，经历了多年的发展，提供了丰富的功能和强大的灵活性。

然而，随着云原生时代的到来，Spring Framework 也面临着新的挑战。

传统的 Spring 应用启动时需要加载大量的类和配置，进行依赖注入和 AOP 织入等操作，导致启动时间较长。

此外，Spring 应用在运行时会占用较多的内存，这在资源受限的云原生环境中也是一个问题。

为了应对这些挑战，Spring 社区积极探索新的解决方案，其中原生镜像和 AOT 编译技术成为了重要的方向。

# 2. 原生镜像（Native Image）与 AOT 编译（Ahead-of-Time Compilation）

原生镜像 (Native Image) 是一种将 Java 应用提前编译成独立可执行文件的技术。它通过 GraalVM 等工具，在构建时对应用进行静态分析，将应用所需的类、依赖和运行时环境打包成一个独立的镜像。由于原生镜像不依赖于 JVM 运行时，因此启动速度非常快，资源占用也很低。

AOT 编译 (Ahead-of-Time Compilation) 是一种在应用部署前将 Java 代码编译成机器码的技术。与传统的 JIT (Just-in-Time) 编译不同，AOT 编译在构建时完成，避免了运行时编译的开销，从而提高了应用的启动速度和性能。Spring Framework 引入了 AOT 引擎，可以在构建时对应用进行优化，生成更高效的代码。

# 二、Spring 对原生镜像和 AOT 的支持

# 1. Spring Boot 3+ 原生镜像支持

# 1.1. Spring Boot 原生镜像支持的目标与架构

曾经由 VMware 积极维护的 Spring Native (opens new window) 项目，其目标是使 Spring 应用能够以原生镜像的方式运行，解决传统 Spring 应用在云原生环境下的启动速度慢、资源占用高等问题。

现在，这项技术已经成熟并被 Spring 官方采纳，集成到 Spring Boot 3+ 中，成为官方的原生镜像支持方案。

Spring Boot 3+ 的原生镜像支持继承了 Spring Native 项目的核心理念和技术积累，并在此基础上进行了改进和增强。

Spring Boot 3+ 原生镜像支持的架构核心组件与之前的 Spring Native 项目类似，但更加成熟和稳定：

  • GraalVM Native Image Compiler: 仍然是构建原生镜像的基础，负责将 Java 字节码编译成特定平台的原生可执行文件。GraalVM 在编译过程中进行静态分析，确定应用所需的类、方法和依赖，并将其打包到原生镜像中。这是 AOT 编译的核心。
  • Spring AOT Engine (集成在 Spring Boot 3+ 核心中): Spring AOT 引擎的功能已经集成到 Spring Boot 3+ 核心框架中，更加无缝和易用。它在构建时对 Spring 应用进行预处理和优化，执行原本需要在运行时才能完成的操作，例如：bean 定义的解析、代理类的生成、配置属性的绑定等。AOT 引擎的优化显著减少了应用在运行时的负担，提高了启动速度。
  • Runtime Hints 机制 (取代 Reflection Configuration 等): 为了支持反射、动态代理等动态特性，Spring Boot 3+ 采用了更加统一和强大的 Runtime Hints 机制。开发者可以通过注解或 RuntimeHintsRegistrar 接口，为 GraalVM 提供运行时所需的元数据信息，包括反射、资源、代理、序列化等方面的 Hints。Runtime Hints 机制更加灵活和易扩展，方便开发者配置各种复杂的运行时需求。
  • Buildpacks 集成: Spring Boot 3+ 官方原生镜像支持与 Cloud Native Buildpacks 深度集成，提供了开箱即用的容器镜像构建方案。开发者可以使用 Maven 或 Gradle 插件，通过简单的命令，即可将 Spring Boot 应用构建成包含原生镜像的 Docker 镜像。Buildpacks 简化了原生镜像的构建流程，降低了使用门槛。

# 1.2. Spring Boot Buildpacks 的作用

Spring Boot Buildpacks 是构建 Spring Boot 容器镜像的关键工具，包括构建原生镜像。 它基于 Cloud Native Buildpacks 规范，能够自动化地将 Spring Boot 应用打包成符合 OCI 标准的容器镜像。

这意味着，无论是传统的 JVM 应用，还是使用 Spring Boot 3+ 原生镜像的应用，都可以通过 Spring Boot Buildpacks 方便地构建 Docker 镜像。

Spring Boot Buildpacks 的核心优势在于其自动化和标准化。它能够自动检测应用的特征，例如是否是 Spring Boot 应用，使用的编程语言版本，依赖管理工具 (Maven 或 Gradle) 等，并根据这些特征选择合适的 Buildpacks 进行构建。

在构建 Spring Boot 原生镜像的过程中，Spring Boot Buildpacks 的作用尤其重要：

  1. 简化构建流程: 开发者无需手动安装和配置 GraalVM、Native Image Compiler 等复杂的工具链。Buildpacks 已经预置了构建原生镜像所需的环境和工具。开发者只需要配置 Maven 或 Gradle 插件，即可通过简单的命令触发原生镜像的构建。
  2. 自动化 Hints 处理: Spring Boot Buildpacks 与 Spring Boot 3+ 原生镜像支持紧密集成，能够自动处理大部分 Hints 配置。Spring Boot 框架和 Buildpacks 会根据应用的依赖和配置，自动生成并应用必要的 Runtime Hints，减少了开发者手动配置 Hints 的工作量。当然，对于一些复杂的应用场景，开发者仍然需要手动添加自定义的 Runtime Hints。
  3. 生成可运行的容器镜像: Buildpacks 不仅构建原生可执行文件，还会将原生可执行文件以及运行时环境 (例如必要的 Linux 库) 打包成一个完整的 Docker 镜像。这个镜像可以直接运行在任何支持 Docker 的环境中，无需额外的配置。
  4. 可扩展性: Cloud Native Buildpacks 规范具有良好的可扩展性。开发者可以自定义 Buildpacks，以满足特定的构建需求。例如，可以自定义 Buildpacks 来添加额外的构建步骤，或者集成其他的 AOT 优化工具。

总而言之，Spring Boot Buildpacks 极大地简化了 Spring Boot 应用 (包括原生镜像应用) 的容器化构建过程，降低了技术门槛，提高了开发效率，是 Spring Boot 3+ 原生镜像支持不可或缺的重要组成部分。

# 2. Spring AOT 引擎

# 2.1. AOT 引擎的工作方式

Spring AOT (Ahead-of-Time) 引擎 (opens new window)是 Spring 的核心组件之一，它负责在构建时对 Spring 应用进行预处理和优化。AOT 引擎的工作方式可以概括为以下几个步骤：

  1. 解析 Bean 定义: AOT 引擎首先会解析 Spring 应用中的 Bean 定义，包括 XML 配置文件、注解和 Java 配置类。
  2. 执行 BeanFactoryPostProcessor: AOT 引擎会执行 BeanFactoryPostProcessor 接口的实现类，对 Bean 定义进行修改和增强。
  3. 生成代理类: 对于需要使用 AOP 的 Bean，AOT 引擎会生成相应的代理类。
  4. 绑定配置属性: AOT 引擎会将配置属性绑定到 Bean 的字段上，例如：@Value 注解。
  5. 生成代码: AOT 引擎会将上述步骤的结果生成 Java 代码，这些代码将在运行时被执行。

通过 AOT 引擎的预处理，可以减少应用在运行时的负担，提高启动速度和性能。

# 2.2. 如何利用 AOT 引擎优化 Spring 应用

要利用 AOT 引擎优化 Spring 应用，可以采取以下几种策略：

  • 使用 Spring Boot 提供的 AOT 支持: Spring Boot 提供了对 AOT 引擎的集成，开发者只需添加相应的依赖，就可以启用 AOT 优化。
  • 使用 Spring Hints 机制: 对于使用反射、动态代理等动态特性的应用，需要提供额外的 Hints 信息，告知 AOT 引擎如何处理这些动态特性。

通过合理的 AOT 优化，可以显著提高 Spring 应用的启动速度和性能。

# 3. Spring Hints 机制

# 3.1. 什么是 Spring Hints？

Spring Hints 是一种机制，它允许 Spring Boot 应用向 Spring Framework 提供关于自身结构的“提示”信息。您可以将 Hints 理解为应用给 Spring Framework 准备的“小抄”，这份小抄详细地告诉 Spring：

  • 哪些类需要在运行时进行反射？ 例如，哪些类的方法或字段会被动态访问。
  • 哪些资源文件需要被包含到最终的应用产物中？ 例如，配置文件、模板文件等。
  • 哪些接口需要在运行时生成动态代理？ 例如，为了实现 AOP 或其他动态行为。
  • 哪些类需要在应用启动时进行初始化？ 例如，一些需要预先加载数据的类。
  • 哪些类需要进行序列化和反序列化？ 例如，用于数据传输或持久化的类。

通过提供这些 Hints 信息，Spring Framework 可以在编译时 (Ahead-of-Time, AOT) 和运行时做出更明智的决策，从而显著优化应用的性能和资源利用率，尤其是在构建原生镜像 (Native Image) 的场景下，Hints 更是至关重要。

# 3.2. Spring Hints 的类型

Spring Hints 根据其描述的动态特性类型，主要可以分为以下几种：

  • Reflection Hints (反射提示): 用于告知 Spring Framework 哪些类、方法、构造器或字段需要在运行时通过反射进行访问。这是最常见、也是最核心的 Hints 类型，覆盖了 JSON 序列化/反序列化、JPA 实体类访问、动态方法调用等众多场景。
  • Resource Hints (资源提示): 用于声明应用在运行时需要访问的资源文件，例如配置文件 (application.properties, application.yml)、国际化资源文件、模板文件、静态资源文件等。确保这些资源在原生镜像中被正确打包和加载。
  • Proxy Hints (代理提示): 用于声明需要在运行时生成动态代理的接口或类。主要用于支持 Spring AOP (面向切面编程)、接口代理、以及 CGLIB 代理等场景。
  • Serialization Hints (序列化提示): 用于声明哪些类需要在运行时进行序列化和反序列化操作。例如，当使用 Java 序列化、JSON 序列化或其他序列化库时，需要注册相应的 Serialization Hints。
  • Initialization Hints (初始化提示): 用于指定哪些类需要在应用启动的早期阶段进行初始化。例如，一些需要预先加载数据或执行初始化逻辑的组件。
  • AotProxyHints (AOT 代理提示): 专门用于在 AOT (Ahead-of-Time) 编译期间提供代理提示信息，通常与 AOT 编译流程紧密结合。
  • RuntimeHints (运行时提示): 一种更为通用的、程序化的 Hints 注册方式，允许开发者注册各种类型的 Hints，包括上述所有类型以及自定义的 Hints。RuntimeHints 接口提供了最大的灵活性和扩展性。

# 3.3. 如何使用 Spring Hints

Spring Boot 提供了多种灵活的方式来配置和使用 Spring Hints，以满足不同场景的需求：

  1. @RegisterReflectionForBinding 注解: 这是一种便捷的注解方式，用于注册需要进行反射的类，尤其适用于配置类或数据绑定 (Data Binding) 的场景。当注解在类上时，它会自动注册该类的所有公共构造器、方法和字段，使其可以被反射访问。

    import org.springframework.aot.hint.annotation.RegisterReflectionForBinding;

@RegisterReflectionForBinding
public class User {
    private String username;
    private String password;
    // ...
}

  2. @Reflective 注解: @Reflective 注解提供了更细粒度的反射控制，可以用于标记类、方法或字段，精确地指定需要进行反射的具体元素。

    import org.springframework.aot.hint.annotation.Reflective;

public class MyService {
    @Reflective
    public String doSomething(String input) {
        return "Result: " + input;
    }
}

  3. RuntimeHintsRegistrar 接口: RuntimeHintsRegistrar 接口提供了程序化注册 Hints 的能力，是功能最强大、最灵活的方式。开发者可以实现 RuntimeHintsRegistrar 接口，并在 registerHints 方法中编写 Java 代码来动态地注册各种类型的 Hints，例如 Reflection Hints, Resource Hints, Proxy Hints 等。

    import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.RuntimeHintsRegistrar;
import org.springframework.aot.hint.ReflectionHints;
import org.springframework.aot.hint.TypeReference;

public class MyHintsRegistrar implements RuntimeHintsRegistrar {

    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        ReflectionHints reflectionHints = hints.reflection();
        // 注册类进行反射
        reflectionHints.registerType(TypeReference.of(MyService.class));
        // 注册方法进行反射 (更精确的控制)
        try {
            reflectionHints.registerMethod(MyService.class.getMethod("doSomething", String.class));
        } catch (NoSuchMethodException e) {
            // ... 异常处理
        }
    }
}

    注册 RuntimeHintsRegistrar 实现类需要在 META-INF/spring.factories 文件中进行配置：

    org.springframework.aot.hint.RuntimeHintsRegistrar=com.example.MyHintsRegistrar

  4. @ImportRuntimeHints 注解: 为了更方便地使用 RuntimeHintsRegistrar，可以使用 @ImportRuntimeHints 注解将 RuntimeHintsRegistrar 实现类导入到 Spring 上下文中，通常与配置类一起使用。

    import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportRuntimeHints;

@Configuration
@ImportRuntimeHints(MyHintsRegistrar.class)
public class AppConfig {
    // ...
}

通过灵活地组合和使用这些 Spring Hints 配置方式，开发者可以有效地解决 Spring Native 应用中的动态性挑战，构建出高性能、低资源消耗的云原生应用。

# 3.4. 测试 Spring Hints

配置和使用 Spring Hints 是确保 Spring Native 应用正确运行的关键步骤。为了验证 Hints 配置的正确性和完整性，Spring 提供了多种测试工具和方法。

1. 使用 RuntimeHintsPredicates 进行单元测试

RuntimeHintsPredicates 是 Spring Core 提供的一个实用工具类，用于检查现有的 RuntimeHints 是否满足特定的用例。它可以用于编写单元测试，验证 RuntimeHintsRegistrar 是否包含了预期的 Hints 信息。

例如，假设我们有一个 SpellCheckService 需要在运行时加载字典文件 dicts/en.txt，我们可以编写一个单元测试来验证是否注册了正确的 Resource Hint：

import org.junit.jupiter.api.Test;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;

import static org.assertj.core.api.Assertions.assertThat;

class SpellCheckServiceRuntimeHintsTests {

    static class SpellCheckServiceRuntimeHints implements RuntimeHintsRegistrar {
        @Override
        public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
            hints.resources().registerResource("dicts/en.txt");
        }
    }

	@Test
	void shouldRegisterResourceHints() {
		RuntimeHints hints = new RuntimeHints();
		new SpellCheckServiceRuntimeHints().registerHints(hints, getClass().getClassLoader());
		assertThat(RuntimeHintsPredicates.resource().forResource("dicts/en.txt"))
				.accepts(hints);
	}
}

RuntimeHintsPredicates 提供了针对不同 Hints 类型的断言方法，例如 resource(), reflection(), serialization(), proxy() 等，可以方便地检查 Resource Hints、Reflection Hints、Serialization Hints 和 Proxy Hints 是否被正确注册。

这种方法适用于对组件的运行时行为非常明确的场景，可以进行细粒度的单元测试。

2. 使用 GraalVM tracing agent 发现运行时 Hints 需求

对于更复杂的应用场景，或者在不确定具体需要哪些 Hints 的情况下，可以使用 GraalVM tracing agent 来辅助发现运行时 Hints 需求。

GraalVM tracing agent (opens new window) 是一个 Java agent，可以在应用运行时记录所有需要 GraalVM Hints 的调用，并将这些调用信息输出为 JSON 配置文件。通过运行应用的测试套件或应用本身，并启用 tracing agent，可以收集应用在运行时实际需要的 Hints 信息，从而帮助开发者更全面地了解 Hints 的需求。

3. 使用 Spring AOT testing utilities 和 RuntimeHints Agent 进行集成测试

Spring Framework 提供了一个专门的模块 spring-core-test，其中包含了 AOT testing utilities，包括 RuntimeHints Agent。

RuntimeHints Agent 是一个 Java agent，它可以记录所有与 Runtime Hints 相关的反射、资源访问、代理创建等方法调用，并帮助开发者断言给定的 RuntimeHints 实例是否覆盖了所有记录的调用。

为了演示如何使用 RuntimeHints Agent 进行测试，我们考虑一个名为 SampleReflection 的类，它使用反射来获取 Spring 版本信息：

import java.lang.reflect.Method;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.util.ClassUtils;

public class SampleReflection {

	private final Log logger = LogFactory.getLog(SampleReflection.class);

	public void performReflection() {
		try {
			Class<?> springVersion = ClassUtils.forName("org.springframework.core.SpringVersion", null);
			Method getVersion = ClassUtils.getMethod(springVersion, "getVersion");
			String version = (String) getVersion.invoke(null);
			logger.info("Spring version: " + version);
		}
		catch (Exception exc) {
			logger.error("reflection failed", exc);
		}
	}
}

我们可以编写一个集成测试，使用 RuntimeHints Agent 来验证是否为 SampleReflection 类注册了正确的 Reflection Hints：

import java.util.List;

import org.junit.jupiter.api.Test;

import org.springframework.aot.hint.ExecutableMode;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.test.agent.EnabledIfRuntimeHintsAgent;
import org.springframework.aot.test.agent.RuntimeHintsInvocations;
import org.springframework.aot.test.agent.RuntimeHintsRecorder;
import org.springframework.core.SpringVersion;

import static org.assertj.core.api.Assertions.assertThat;

@EnabledIfRuntimeHintsAgent // 仅在 RuntimeHintsAgent 启用时运行测试
class SampleReflectionRuntimeHintsTests {

	@Test
	void shouldRegisterReflectionHints() {
		RuntimeHints runtimeHints = new RuntimeHints();
		// 注册 Reflection Hints，例如：
		runtimeHints.reflection().registerType(SpringVersion.class, typeHint ->
				typeHint.withMethod("getVersion", List.of(), ExecutableMode.INVOKE));

		// 在 RuntimeHintsRecorder.record() 中执行需要测试的代码
		RuntimeHintsInvocations invocations = RuntimeHintsRecorder.record(() -> {
			SampleReflection sample = new SampleReflection();
			sample.performReflection();
		});
		// 断言记录的调用是否被 Hints 覆盖
		assertThat(invocations).match(runtimeHints);
	}
}

@EnabledIfRuntimeHintsAgent 注解用于标记测试类或测试方法，表示只有当 RuntimeHints Agent 作为 Java agent 启动时，测试才会被执行。RuntimeHintsRecorder.record() 方法用于包裹需要测试的代码逻辑，RuntimeHintsInvocations 用于记录在 record() 代码块中发生的与 Hints 相关的调用。assertThat(invocations).match(runtimeHints) 用于断言记录的调用是否与提供的 RuntimeHints 相匹配。

如果 Hints 配置不完整，测试将会失败，并提供详细的错误信息，例如缺失的 Hints 类型、调用的方法签名、以及堆栈信息，帮助开发者快速定位和修复 Hints 配置问题。

配置 RuntimeHints Agent

RuntimeHints Agent 可以通过多种方式配置，例如在 Maven 或 Gradle 构建工具中配置 Java agent 参数，或者在 IDE 中配置 JVM 参数。具体的配置方式可以参考 Spring Framework 的 buildSrc/README.md (opens new window) 文件以及构建工具和测试执行插件的文档。Agent 还可以配置需要 instrument 的包，默认情况下只 instrument org.springframework 包。

通过结合单元测试、tracing agent 和 RuntimeHints Agent 等多种测试手段，开发者可以更加全面和有效地测试 Spring Hints 配置，确保 Spring Native 应用在原生镜像环境中能够稳定可靠地运行。

# 三、Spring 原生镜像实战

本章将深入探讨如何将 Spring Boot 应用构建为原生镜像，并进行实际操作和性能调优。

通过本章的学习，你将能够掌握 Spring Boot 3+ 原生镜像从环境搭建到性能优化的全流程，并了解两种主要的构建方式：使用 Cloud Native Buildpacks 和 GraalVM Native Build Tools。

# 1. 环境准备

构建 Spring Boot 原生镜像，需要配置特定的开发环境。本节将指导你完成 GraalVM、Native Build Tools 的安装，以及 Maven 或 Gradle 的配置。

# 1.1. 安装 GraalVM 和 Native Build Tools

GraalVM 是构建 Spring Boot 原生镜像的核心工具。你需要安装 GraalVM 发行版以及 Native Build Tools 组件。

  1. 安装 GraalVM 发行版

    首先，你需要下载并安装 GraalVM。推荐使用 Liberica Native Image Kit (Liberica NIK)，这是一个基于 GraalVM CE 构建的发行版，专门为构建原生镜像优化。

    访问 Liberica Native Image Kit 下载页面 (opens new window) ，选择与你的操作系统匹配的 JDK 17 或更高版本。下载完成后，按照 Liberica NIK 的安装指南进行安装。

    安装完成后，你需要配置 JAVA_HOME 环境变量指向 Liberica NIK 的安装目录，并将 GraalVM 的 bin 目录添加到 PATH 环境变量中。

    你可以通过以下命令验证 GraalVM 是否安装成功：

    java -version
javac -version

    如果正确显示 Liberica NIK 的版本信息，则说明 GraalVM 安装成功。

  2. 安装 Native Image 组件

    Liberica NIK 通常已经包含了 Native Image 组件。你可以通过以下命令验证 native-image 命令是否可用：

    native-image --version

    如果命令可用，则无需额外安装 Native Build Tools。如果 native-image 命令不可用，你需要使用 GraalVM 的 gu 工具安装 native-image 组件。请参考 Liberica NIK 的官方文档进行安装。

    确保 native-image 命令在你的 PATH 环境变量中可用。

# 1.2. 配置 Maven 或 Gradle

为了在 Maven 或 Gradle 项目中使用 Spring Boot 原生镜像构建功能，你需要确保项目中引入了相应的插件。Spring Boot 3+ 官方支持使用 Maven 和 Gradle 插件构建原生镜像。

  1. 配置 Maven

    在你的 Maven 项目的 pom.xml 文件中，你需要确保使用了 spring-boot-starter-parent 作为父 POM，并引入了 org.graalvm.buildtools:native-maven-plugin 插件。

    • 检查 spring-boot-starter-parent

      你的 <parent> 部分应该类似于：

      <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.x</version> <!-- 请使用 Spring Boot 3.x 或更高版本 -->
</parent>

      请确保 version 为 Spring Boot 3.x 或更高版本。

    • 添加 native-maven-plugin 插件

      在 <build><plugins> 标签中添加以下内容：

      <plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
</plugin>

      spring-boot-starter-parent 已经声明了 native profile，并配置了构建原生镜像所需的 executions。

  2. 配置 Gradle

    对于 Gradle 项目，你需要确保应用了 org.graalvm.buildtools.native 插件。

    在你的 build.gradle.kts 文件 (或 build.gradle) 的 plugins 代码块中添加：

    plugins {
    id("org.springframework.boot") version "{spring-boot-version}" // 确保 Spring Boot 版本为 3.x 或更高
    id("io.spring.dependency-management") version "{dependency-management-version}"
    id("org.graalvm.buildtools.native") version "{native-buildtools-version}" // 请使用最新版本
}

    请替换 {spring-boot-version}, {dependency-management-version}, 和 {native-buildtools-version} 为实际的版本号。你可以在 Gradle Plugin Portal (opens new window) 上查找 org.graalvm.buildtools.native 插件的最新版本。

    应用 org.graalvm.buildtools.native 插件后，Spring Boot Gradle 插件会自动配置 AOT 编译任务。

完成上述步骤后，你的开发环境就配置完成了，可以开始构建 Spring Boot 原生镜像了。

# 2. 示例项目构建

本节将引导你创建一个简单的 Spring Boot 应用，并演示如何构建原生镜像。

# 2.1. 创建一个简单的 Spring Boot 应用

你可以使用 Spring Initializr (https://start.spring.io/ (opens new window)) 快速创建一个 Spring Boot 项目。选择以下配置：

  • Project: Maven 或 Gradle (根据你的偏好)
  • Language: Java
  • Spring Boot: 3.2.x 或更高版本 (推荐使用最新稳定版)
  • Group: com.example (或其他你喜欢的 Group ID)
  • Artifact: native-demo (或其他你喜欢的 Artifact ID)
  • Dependencies: Spring Web

点击 "GENERATE" 下载项目压缩包，解压到你的工作目录。

打开项目，在 src/main/java/com/example/nativedemo 目录下，创建一个简单的 REST Controller HelloController.java:

package com.example.nativedemo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello, Native Image!";
    }
}

这是一个最简单的 Spring Boot Web 应用，只有一个 / 路径的 GET 接口，返回 "Hello, Native Image!" 字符串。

# 2.2. 无需显式添加 Spring Native 依赖

在 Spring Boot 3+ 中，构建原生镜像不再需要显式添加 spring-native 依赖。 原生镜像支持已经集成在 Spring Boot 3+ 核心框架中。你只需要确保你的 Spring Boot 版本为 3.x 或更高，并配置了 Maven 或 Gradle 插件即可。

# 2.3. 配置 Runtime Hints (如果需要)

对于我们这个简单的 HelloController 示例，通常 不需要额外的 Runtime Hints 配置，Spring Boot 能够自动处理。

但在实际项目中，如果遇到与反射、资源访问、代理或序列化相关的问题，你可能需要实现 RuntimeHintsRegistrar 接口，并注册自定义的 Runtime Hints。

# 3. 构建与测试

本节将介绍如何使用 Maven 或 Gradle 构建原生镜像，并验证原生镜像的运行效果。你可以选择使用 Buildpacks 或 Native Build Tools 两种方式构建原生镜像。

# 3.1. 使用 Maven 或 Gradle 构建原生镜像

# 3.1.1. 使用 Buildpacks 构建容器镜像 (推荐)

使用 Buildpacks 是 Spring Boot 官方推荐的构建原生镜像的方式。它可以将你的 Spring Boot 应用直接打包成包含原生可执行文件的 Docker 镜像，简化了部署流程。

  • Maven 项目

    在项目根目录下，打开终端，确保 Docker daemon 正在运行，然后执行以下 Maven 命令：

    mvn spring-boot:build-image -Pnative

    -Pnative 激活了 native profile，该 profile 由 spring-boot-starter-parent 定义，用于配置原生镜像构建。 spring-boot:build-image 目标由 Spring Boot Maven 插件提供，它会使用 Cloud Native Buildpacks 和 Paketo Java Native Image buildpack 构建 Docker 镜像。

  • Gradle 项目

    在项目根目录下，打开终端，确保 Docker daemon 正在运行，然后执行以下 Gradle 任务：

    ./gradlew bootBuildImage

    bootBuildImage 任务由 Spring Boot Gradle 插件提供，当检测到 org.graalvm.buildtools.native 插件时，会自动构建原生镜像 Docker 镜像。

构建过程可能需要一些时间，具体取决于你的网络速度和项目规模。构建成功后，Docker 镜像将被推送到本地 Docker daemon。镜像名称通常为 docker.io/library/{artifactId}:{version}，例如 docker.io/library/native-demo:0.0.1-SNAPSHOT。

# 3.1.2. 使用 Native Build Tools 构建本地可执行文件

如果你只需要构建本地可执行文件，而不需要 Docker 镜像，可以使用 Native Build Tools 提供的 Maven 或 Gradle 目标/任务。

  • Maven 项目

    在项目根目录下，打开终端，执行以下 Maven 命令：

    mvn native:compile -Pnative

    native:compile 目标由 native-maven-plugin 插件提供，它会直接调用 native-image 编译器构建本地可执行文件。

  • Gradle 项目

    在项目根目录下，打开终端，执行以下 Gradle 任务：

    ./gradlew nativeCompile

    nativeCompile 任务由 org.graalvm.buildtools.native 插件提供，它会直接调用 native-image 编译器构建本地可执行文件。

构建成功后，本地可执行文件会生成在 target/native/native-image (Maven) 或 build/native/nativeCompile (Gradle) 目录下。

# 3.2. 原生镜像的测试与验证

# 3.2.1. 测试 Docker 容器镜像 (Buildpacks 构建)

  1. 运行 Docker 镜像

    使用 docker run 命令运行使用 Buildpacks 构建的 Docker 镜像。例如：

    docker run --rm -p 8080:8080 docker.io/library/native-demo:0.0.1-SNAPSHOT

    --rm 选项表示容器退出后自动删除， -p 8080:8080 将容器的 8080 端口映射到主机的 8080 端口。请替换 docker.io/library/native-demo:0.0.1-SNAPSHOT 为你的实际镜像名称。

    你会看到 Spring Boot 应用的启动日志。原生镜像容器的启动速度非常快。

  2. 验证应用功能

    使用 curl 或浏览器访问 http://localhost:8080/，验证应用功能是否正常。对于我们的 HelloController 示例，你应该看到返回 "Hello, Native Image!" 字符串。

# 3.2.2. 测试本地可执行文件 (Native Build Tools 构建)

  1. 运行本地可执行文件

    打开终端，进入本地可执行文件所在的目录 (例如 target/native/native-image 或 build/native/nativeCompile)，执行以下命令运行原生镜像：

    ./native-demo  # Linux 或 macOS
native-demo.exe # Windows

  2. 验证应用功能

    与测试 Docker 镜像类似，使用 curl 或浏览器访问 http://localhost:8080/ ，验证应用功能。

# 3.2.3. 对比性能

对比原生镜像和传统的 JVM 应用的启动时间，你会发现原生镜像的启动速度有显著提升。可以使用 time 命令或 Spring Boot Actuator 的 /startup endpoint 进行更精确的测量。

你也可以使用 Docker 命令 (例如 docker stats) 或系统监控工具观察原生镜像容器和 JVM 应用的内存占用情况，原生镜像的资源效率通常更高。

# 4. 性能调优

虽然原生镜像已经具有出色的启动速度和内存占用，但在某些场景下，你可能还需要进一步优化性能。本节将介绍一些常见的性能调优策略。

# 4.1. 启动时间、内存占用等指标的监控

在进行性能调优之前，首先需要监控和测量关键的性能指标，例如启动时间、内存占用、以及应用的吞吐量和延迟等。

  • 启动时间

    如前所述，可以使用 time 命令测量应用的启动时间。更精确的测量可以使用 Spring Boot Actuator 的 /startup endpoint (如果你的项目引入了 spring-boot-starter-actuator 依赖)。

  • 内存占用

    可以使用系统监控工具 (例如 top, htop, jconsole, VisualVM 等) 监控应用的内存占用情况。对于原生镜像，关注其 Resident Set Size (RSS) 指标，反映了实际使用的物理内存大小。

  • 吞吐量和延迟

    可以使用性能测试工具 (例如 JMeter, Gatling, wrk 等) 对应用的接口进行压力测试，测量其吞吐量 (每秒请求数) 和延迟 (请求响应时间)。

  • Profiling

    对于更深入的性能分析，可以使用 profiling 工具，例如 Java Flight Recorder (JFR), Async Profiler 等。虽然原生镜像的 profiling 工具链相对 JVM 较弱，但仍然有一些工具可以帮助你分析性能瓶颈。例如，可以使用 GraalVM 的 chrome-profiler 工具生成 Chrome DevTools 可以加载的 profiling 数据。

通过监控和测量，你可以了解应用的性能瓶颈，并有针对性地进行优化。

# 4.2. 常见的性能优化策略

针对 Spring Native 原生镜像，以下是一些常见的性能优化策略：

  1. 减少反射使用

    反射是 Java 动态性的重要特性，但在原生镜像中，过多的反射会增加镜像的大小和启动时间。尽量避免不必要的反射，优先使用 AOT 友好的编程方式。如果必须使用反射，请确保正确配置 @RegisterReflectionForBinding 等 Hints。

  2. 优化依赖

    精简应用的依赖，移除不必要的依赖库。可以使用 Maven 或 Gradle 的依赖分析工具，找出未使用的依赖并移除。减少依赖可以减小镜像大小，提升启动速度。

  3. 资源优化

    只包含必要的资源文件到原生镜像中。默认情况下，Spring Native 会包含 META-INF/resources, resources, static, public 等目录下的资源。如果你的应用只使用部分资源，可以使用 @Resource 注解或 RuntimeHintsRegistrar 精确控制需要包含的资源。

  4. 代码优化

    编写高效的代码，避免不必要的对象创建和内存分配。虽然原生镜像在 AOT 编译阶段进行了一些优化，但良好的代码习惯仍然非常重要。

  5. 构建参数调优

    native-image 编译器提供了一些构建参数，可以影响原生镜像的性能。例如，-Obito 参数可以启用实验性的位码优化，-H:+RemoveSaturatedTypeChecks 可以移除饱和类型检查 (可能带来一定的风险，需谨慎使用)。可以根据具体情况尝试调整构建参数，但需要仔细测试和评估效果。

  6. Profile-guided Optimization (PGO) (实验性)

    GraalVM Native Image 提供了 Profile-guided Optimization (PGO) (opens new window) 的支持，可以根据应用的运行时 profile 信息，进一步优化原生镜像的性能。PGO 是一种高级优化技术，配置和使用相对复杂，但可以带来显著的性能提升。

  7. 迭代优化

    性能优化是一个迭代的过程。每次优化后，都需要重新构建、测试、和测量性能指标，验证优化效果。根据测量结果，不断调整优化策略，直到达到满意的性能水平。

性能调优是一个持续的过程，需要结合具体的应用场景和性能瓶颈，选择合适的优化策略。希望本节介绍的策略能够帮助你更好地优化 Spring Native 原生镜像的性能。

# 四、总结与展望

经过前几章的介绍和实战，相信你对 Spring Native 和 AOT 技术有了更深入的理解。本章将对 Spring Native 的优势与局限性进行总结，并展望其未来的发展趋势，最后为 Spring 开发者提出一些建议。

# 1. 优势与局限

Spring Native 作为一项新兴技术，在带来显著优势的同时，也存在一些局限性。了解这些优势和局限性，有助于我们更好地评估和应用 Spring Native。

# 1.1. Spring Native 的优势：启动速度、资源效率

Spring Native 最显著的优势体现在启动速度和资源效率上，这主要归功于 AOT 编译技术带来的变革：

  1. 极速启动: 原生镜像应用无需 JVM 预热，直接执行编译后的机器码，启动时间大幅缩短。传统的 Spring Boot 应用启动可能需要数秒甚至数十秒，而 Spring Native 应用往往能在毫秒级完成启动。这对于 Serverless 函数、微服务等场景至关重要，可以显著降低冷启动延迟，提升应用响应速度。

    例如，在云原生环境中，服务的快速扩容和弹性伸缩依赖于快速启动能力。Spring Native 可以使应用在几百毫秒内启动并对外提供服务，相比传统 JVM 应用的数秒启动时间，优势明显。

  2. 超低资源占用: 原生镜像应用由于去除了 JVM 运行时，内存占用和 CPU 消耗大幅降低。传统的 JVM 应用需要 JVM 虚拟机本身占用一部分资源，而原生镜像应用直接以机器码运行，只占用应用自身所需的资源。这降低了基础设施成本，尤其是在高密度部署的场景下，资源效率的提升非常可观。

    例如，在资源受限的边缘计算场景或移动设备上，内存和 CPU 资源非常宝贵。Spring Native 可以使 Spring 应用在这些资源受限的环境下高效运行，扩展了 Spring 应用的应用范围。

  3. 增强安全性: 原生镜像应用将应用编译成机器码，一定程度上降低了代码被逆向工程的风险。虽然不能完全阻止逆向工程，但增加了难度，提升了应用的安全性。

  4. 更小的发布包: 原生镜像通常比传统的 JAR 包更小，这降低了存储空间和网络传输带宽的需求，尤其是在容器化部署和云原生环境中，镜像大小的优化非常重要。

总而言之，Spring Native 的优势主要集中在提升应用性能和资源效率，使其更适合云原生、Serverless 等新兴应用场景。

# 1.2. Spring Native 的局限：兼容性、构建时间、复杂性

尽管 Spring Native 优势显著，但作为一项相对年轻的技术，也存在一些不可忽视的局限性：

  1. 兼容性限制: 并非所有的 Java 特性和库都能完美支持 AOT 编译。反射、动态代理、字节码生成等动态特性在 AOT 环境下受到限制。虽然 Spring Native 提供了 Hints 机制来解决部分兼容性问题，但仍然存在一些场景无法完美支持。

    例如，一些依赖于运行时字节码增强的库，可能需要进行适配才能在 Spring Native 环境下正常工作。一些传统的 Java EE 技术，如动态生成的 JPA Criteria 查询，可能需要调整为更 AOT 友好的方式。

  2. 构建时间长: 原生镜像的构建过程需要进行静态分析、代码优化和本地编译等步骤，相比传统的 JAR 包构建，构建时间显著增加。对于大型应用，构建时间可能长达数十分钟甚至数小时。这会影响开发效率和 CI/CD 流程的迭代速度。

    虽然 GraalVM Native Image 团队在持续优化构建性能，但构建时间仍然是 Spring Native 的一个重要考量因素。在开发阶段，可以考虑只在最终部署阶段构建原生镜像，而在开发和测试阶段仍然使用传统的 JVM 运行模式，以提升开发效率。

  3. 开发和调试复杂性: AOT 编译环境与传统的 JVM 运行时环境存在差异，可能会引入一些在 JVM 环境下不常见的问题。例如，Hints 配置不正确可能导致运行时错误，而这些错误在 JVM 环境下可能不会出现。调试原生镜像应用也相对复杂，传统的远程调试方式可能不再适用，需要使用特定的调试工具和方法。

    Spring 团队也在努力简化开发和调试流程，例如通过更智能的 Hints 自动生成、更友好的错误提示、以及改进的调试工具支持等，来降低开发和调试的复杂性。

  4. 学习曲线: 理解 AOT 编译原理、掌握 Hints 配置、以及解决兼容性问题，都需要一定的学习成本。对于不熟悉 AOT 技术的开发者来说，Spring Native 的学习曲线相对陡峭。

    Spring Native 社区正在努力提供更完善的文档、示例和教程，降低学习门槛，帮助开发者更快上手 Spring Native。

  5. 生态系统成熟度: 相比 JVM 生态，Spring Native 生态系统尚不成熟。一些常用的库和框架可能尚未完全适配 Spring Native，或者缺少完善的 AOT 支持。

    随着 Spring Native 的发展和普及，越来越多的库和框架将逐步适配 Spring Native，生态系统会逐渐成熟和完善。

总而言之，Spring Native 的局限性主要体现在兼容性、构建时间和复杂性上。在选择是否使用 Spring Native 时，需要综合考虑其优势和局限性，并根据具体的应用场景和需求做出权衡。

# 2. 未来展望

Spring Native 作为 Spring 生态拥抱云原生时代的重要战略，其未来发展前景广阔。同时，AOT 编译技术本身也在不断演进，将对软件开发产生深远影响。

# 2.1. Spring Native 的发展趋势

Spring Native 正处于快速发展阶段，未来的发展趋势主要体现在以下几个方面：

  1. 更完善的兼容性: Spring 团队将持续提升对 Java 特性和库的兼容性，减少兼容性限制。例如，通过改进 Hints 机制、优化 AOT 编译流程、以及与第三方库的合作，来解决更多的兼容性问题。

  2. 更快的构建速度: GraalVM Native Image 团队将持续优化 native-image 编译器的性能，缩短构建时间。例如，通过增量编译、并行编译、以及更高效的静态分析算法，来提升构建速度。

  3. 更简化的开发体验: Spring 团队将致力于简化开发和调试流程，降低开发复杂性。例如，通过更智能的 Hints 自动生成、更友好的错误提示、以及更易用的调试工具，来提升开发效率。

  4. 更成熟的生态系统: 随着 Spring Native 的普及，越来越多的 Spring 生态组件和第三方库将提供原生的 AOT 支持，形成更成熟的 Spring Native 生态系统。

  5. 更紧密的云原生集成: Spring Native 将更紧密地与云原生技术栈集成，例如 Kubernetes、Serverless 平台等。例如，通过更好的容器镜像支持、更高效的资源管理、以及与云平台更深度的集成，来提升 Spring 应用在云原生环境下的竞争力。

总而言之，Spring Native 的未来发展方向是不断提升其易用性、性能和兼容性，并构建更成熟的生态系统，使其成为 Spring 开发者构建云原生应用的首选技术。

# 2.2. AOT 编译技术的演进

AOT 编译技术不仅仅局限于 Spring Native，它代表着一种软件开发模式的转变。未来 AOT 编译技术将会在以下方面持续演进：

  1. 更广泛的应用场景: AOT 编译技术将不仅仅应用于 Java 生态，还会扩展到更多的编程语言和平台。例如，Go、Rust 等语言本身就具有 AOT 编译能力，C++、C# 等语言也在积极探索 AOT 编译技术。

  2. 更强大的优化能力: AOT 编译器将具备更强大的静态分析和代码优化能力，生成更高效的机器码。例如，通过更深度的控制流分析、数据流分析、以及跨函数优化，来提升应用性能。

  3. 更灵活的编译配置: AOT 编译器将提供更灵活的编译配置选项，允许开发者根据不同的应用场景和性能需求，定制编译过程。例如，可以选择不同的优化级别、配置特定的编译参数、以及选择性地启用或禁用某些优化特性。

  4. 与 JIT 编译的融合: 未来 AOT 编译和 JIT (Just-In-Time) 编译技术可能会融合发展，取长补短。例如，可以利用 AOT 编译生成应用的初始版本，然后在运行时使用 JIT 编译对热点代码进行动态优化，从而兼顾启动速度和运行时性能。

  5. 编译即服务 (Compilation as a Service): 随着云计算技术的发展，编译过程可能会云化，出现 "编译即服务" 的模式。开发者可以将代码提交到云端编译服务，云端服务利用强大的计算资源进行 AOT 编译，并将编译结果返回给开发者。这将大大缩短本地构建时间，提升开发效率。

总而言之，AOT 编译技术将持续演进，并在软件开发领域扮演越来越重要的角色，推动软件开发模式的变革，提升软件的性能和效率。

# 2.3. 对 Spring 开发者的建议

对于 Spring 开发者，面对 Spring Native 和 AOT 编译技术，以下是一些建议：

  1. 积极关注和学习 Spring Native: Spring Native 是 Spring 生态的重要发展方向，建议 Spring 开发者积极关注和学习 Spring Native 技术，了解其优势、局限性和发展趋势。

  2. 评估项目是否适合 Spring Native: 在实际项目中，需要根据项目的具体需求和特点，评估是否适合采用 Spring Native。如果项目对启动速度和资源效率有较高要求，并且能够接受 Spring Native 的一些局限性，可以考虑尝试 Spring Native。

  3. 逐步尝试和实践: 可以从简单的 Spring Boot 应用开始，逐步尝试 Spring Native。例如，可以将一些对性能敏感的微服务或 Serverless 函数迁移到 Spring Native 环境。

  4. 关注 Hints 配置和兼容性: 在使用 Spring Native 的过程中，需要重点关注 Hints 配置和兼容性问题。仔细阅读 Spring Native 文档，了解 Hints 的配置方法，并测试应用在原生镜像环境下的运行情况，及时解决兼容性问题。

  5. 参与 Spring Native 社区: 积极参与 Spring Native 社区，例如参与讨论、提交 issue、贡献代码等。通过社区交流，可以更好地了解 Spring Native 的最新进展，并与其他开发者共同推动 Spring Native 的发展。

  6. 拥抱 AOT 友好的编程模式: 在日常开发中，可以逐步尝试采用更 AOT 友好的编程模式，例如减少反射、避免动态代理、使用静态配置等。这不仅有助于更好地支持 Spring Native，也有助于提升代码的可维护性和性能。

总而言之，Spring Native 是一项充满潜力的技术，值得 Spring 开发者关注和学习。在实际应用中，需要根据具体情况进行评估和选择，并逐步探索和实践，才能充分发挥 Spring Native 的优势，构建更高效、更轻量级的 Spring 应用。

至此，我们完成了关于 Spring 对于原生镜像和 AOT 支持的系列文章。

希望本系列文章能够帮助你深入理解 Spring Native 和 AOT 技术，并在实际项目中应用这些技术，构建更优秀的 Spring 应用。

祝你变得更强!

编辑 (opens new window)
上次更新: 2025/02/13
Spring数据缓冲区与编解码器详解
Spring中的数据访问：JDBC、R2DBC、ORM、Object-XML

← Spring中的数据访问：JDBC、R2DBC、ORM、Object-XML→

最近更新
01
Spring Boot版本新特性
09-15
02
Spring框架版本新特性
09-01
03
Spring Boot开发初体验
08-15
更多文章>
Theme by Vdoing | Copyright © 2018-2025 京ICP备2021021832号-2 | MIT License