Rust FFI 与 JNI：实现 Java 与 Rust 的无缝集成 – wiki大全

作者： /

Rust FFI 与 JNI：实现 Java 与 Rust 的无缝集成

在现代软件开发中，不同编程语言之间的互操作性变得越来越重要。Java 以其跨平台能力和庞大的生态系统占据主导地位，而 Rust 则以其卓越的性能、内存安全和并发能力迅速崛起。将这两种语言的优势结合起来，可以为构建高性能、安全且易于维护的应用程序提供强大的解决方案。本文将深入探讨如何利用 Rust 的外部函数接口（FFI）和 Java 原生接口（JNI）来实现 Java 与 Rust 之间的无缝集成。

为什么需要 Java 与 Rust 集成？

Java 虚拟机（JVM）提供了一个健壮的运行环境，拥有丰富的库和框架。然而，对于某些计算密集型任务，如图像处理、密码学、高性能科学计算或操作系统级别的交互，Java 的性能可能无法满足严格的要求。此外，某些遗留 C/C++ 代码库可能需要被 Java 应用程序调用。

Rust 在这些场景中表现出色。它提供了零成本抽象、强大的类型系统和所有权模型，确保了内存安全和线程安全，同时其性能可以媲美 C/C++。通过将关键性能部分用 Rust 编写，并将其集成到 Java 应用程序中，开发者可以获得两全其美的优势：Java 的生产力与 Rust 的性能和安全性。

1. Rust 的外部函数接口（FFI）

FFI（Foreign Function Interface）允许一种编程语言调用另一种编程语言中定义的函数。对于 Rust 而言，FFI 主要用于与 C 语言接口。这是因为 C 语言有一个稳定的 ABI（Application Binary Interface），被大多数系统和编程语言广泛支持。

1.1 extern "C"

为了让 Rust 函数可以被外部语言（如 C/C++ 或通过 JNI 间接被 Java）调用，我们需要使用 extern "C" 块来定义这些函数。这会指示 Rust 编译器按照 C 语言的调用约定来编译这些函数，包括名称修饰（name mangling）、参数传递顺序和返回值处理。

“`rust
// lib.rs

[no_mangle] // 防止 Rust 编译器修改函数名

pub extern “C” fn greet_from_rust(name_ptr: *const libc::c_char) {
let c_str = unsafe {
assert!(!name_ptr.is_null());
std::ffi::CStr::from_ptr(name_ptr)
};
let name = c_str.to_str().expect(“invalid UTF-8 string”);
println!(“Hello, {} from Rust!”, name);
}

[no_mangle]

pub extern “C” fn add(a: i32, b: i32) -> i32 {
a + b
}
“`

  • #[no_mangle]: 这是一个属性，告诉 Rust 编译器不要对函数名进行修饰。如果 Rust 对函数名进行了修饰，外部语言将无法找到正确的函数入口点。
  • pub extern "C": pub 使函数公开可见，extern "C" 指定了 C 调用约定。
  • 参数和返回值类型: Rust 和 C 语言的基本类型（如 i32 对应 int）通常可以直接映射。对于字符串，通常通过 C 风格的字符指针 (*const libc::c_char) 来传递。

1.2 构建 Rust 动态链接库

为了让 Java 能够加载和调用 Rust 代码，我们需要将 Rust 代码编译成动态链接库（.so 在 Linux/macOS 上，.dll 在 Windows 上）。

在 Cargo.toml 中，添加以下配置：

toml
[lib]
name = "myrustlib" # 库的名称，Java 加载时使用
crate-type = ["cdylib"] # 编译为 C 动态链接库

然后运行 cargo build --release。这将在 target/release/ 目录下生成 libmyrustlib.so (或 .dll, .dylib)。

2. Java 原生接口（JNI）

JNI（Java Native Interface）是 Java 平台的一个标准编程接口，它允许 Java 代码与其他语言（主要是 C/C++）编写的应用程序和库进行交互。通过 JNI，Java 程序可以调用原生库中的函数，原生库也可以调用 Java 代码中的方法。

2.1 声明原生方法

在 Java 代码中，你需要声明一个 native 方法。这个方法没有 Java 实现，它的实现将由原生库提供。

``java
// MyRustIntegrator.java
public class MyRustIntegrator {
// 静态块加载动态链接库
static {
// 库名称与 Cargo.toml 中的name字段一致，但不包含lib` 前缀和文件后缀
System.loadLibrary(“myrustlib”);
}

// 声明一个原生方法，其实现将由 Rust 提供
public native void greetFromRust(String name);
public native int add(int a, int b);

public static void main(String[] args) {
    MyRustIntegrator integrator = new MyRustIntegrator();
    integrator.greetFromRust("Java User");
    int sum = integrator.add(10, 20);
    System.out.println("Sum from Rust: " + sum);
}

}
“`

2.2 生成 JNI 头文件

为了让 Rust 知道如何实现这些原生方法，我们需要使用 javac 和 javah（或 javac -h，从 Java 8 开始）来生成 JNI 头文件。

  1. 编译 Java 代码：javac MyRustIntegrator.java
  2. 生成 JNI 头文件：javah MyRustIntegrator (如果你使用的是 Java 8 或更早版本) 或 javac -h . MyRustIntegrator.java (对于 Java 9 及更高版本，此命令会直接生成 .h 文件)。

这将生成一个名为 MyRustIntegrator.h 的头文件，其中包含了原生方法对应的 C 函数签名。

“`c
/ DO NOT EDIT THIS FILE – it is machine generated /

include

/ Header for class MyRustIntegrator /

ifndef _Included_MyRustIntegrator

define _Included_MyRustIntegrator

ifdef __cplusplus

extern “C” {

endif

/
* Class: MyRustIntegrator
* Method: greetFromRust
* Signature: (Ljava/lang/String;)V
/
JNIEXPORT void JNICALL Java_MyRustIntegrator_greetFromRust
(JNIEnv *, jobject, jstring);

/
* Class: MyRustIntegrator
* Method: add
* Signature: (II)I
/
JNIEXPORT jint JNICALL Java_MyRustIntegrator_add
(JNIEnv *, jobject, jint, jint);

ifdef __cplusplus

}

endif

endif

“`

请注意函数名的格式：Java_PackageName_ClassName_MethodName。JNIEnv 是一个指向 JNI 环境的指针，允许你与 JVM 交互；jobject 是调用该方法的 Java 对象的引用；jstring、jint 等是 JNI 提供的 Java 类型到 C 类型的映射。

2.3 在 Rust 中实现 JNI 方法

现在，我们需要在 Rust 库中实现 MyRustIntegrator.h 中声明的 C 函数。

“`rust
// lib.rs (继续在之前的 lib.rs 中添加)
use jni::JNIEnv;
use jni::objects::{JObject, JString};
use jni::sys::{jint, jstring}; // 引入 JNI 基本类型

// 实现 greetFromRust

[no_mangle]

[allow(non_snake_case)] // JNI 函数名不遵循 Rust 命名规范

pub extern “system” fn Java_MyRustIntegrator_greetFromRust<‘local>(
mut env: JNIEnv<‘local>,
_obj: JObject<‘local>, // this
name: JString<‘local>,
) {
// 将 JString 转换为 Rust String
let input_string: String = env.get_string(&name).expect(“Couldn’t get java string!”).into();
println!(“Hello, {} from Rust JNI!”, input_string);

// 也可以调用之前定义的 FFI 函数
// let c_str = std::ffi::CString::new(input_string).unwrap();
// greet_from_rust(c_str.as_ptr()); // 直接调用 C FFI 函数

}

// 实现 add

[no_mangle]

[allow(non_snake_case)]

pub extern “system” fn Java_MyRustIntegrator_add(
_env: JNIEnv,
_obj: JObject,
a: jint,
b: jint,
) -> jint {
a + b // 直接使用 jint 类型进行计算
}
“`

  • extern "system": 这是一个特殊的调用约定，通常用于 JNI 函数，它与平台相关的 C 调用约定兼容。
  • jni crate: Rust 有一个优秀的 jni crate，它简化了 JNI 编程。你需要将其添加到 Cargo.toml 的 dependencies 中：
    toml
    [dependencies]
    jni = "0.21.1" # 使用最新版本
  • 类型转换: JNI 环境 (JNIEnv) 提供了方法来在 Java 类型（如 JString, jint）和 Rust 类型之间进行转换。例如，env.get_string() 用于从 JString 获取 Rust String。

3. 集成与运行

  1. 编译 Rust 库: 确保 Cargo.toml 配置正确，然后运行 cargo build --release。
  2. 运行 Java 应用程序:
  3. 确保 MyRustIntegrator.class 文件存在。
  4. 确保 Rust 生成的动态链接库（libmyrustlib.so 或 .dll）在 Java 的库路径中。最简单的方法是将其放在与 MyRustIntegrator.class 同级的目录下。
  5. 运行 Java：
    bash
    java MyRustIntegrator
    如果库文件不在当前目录，你可能需要指定 -Djava.library.path：
    bash
    java -Djava.library.path=. MyRustIntegrator

预期输出：

Hello, Java User from Rust JNI!
Sum from Rust: 30

4. 优势与考量

优势：

  • 性能提升: 将计算密集型任务委托给 Rust，可以显著提高应用程序的性能。
  • 内存安全: Rust 的所有权和借用机制消除了 C/C++ 中常见的内存错误，如空指针解引用和数据竞争。
  • 并发安全: Rust 的类型系统和安全并发原语使得编写无数据竞争的并行代码变得更容易。
  • 利用原生库: 可以方便地集成现有的高性能 C/C++ 库。
  • 跨平台兼容: Rust 库可以编译为各种平台上的动态链接库，与 Java 的跨平台特性相得益彰。

考量与挑战：

  • 学习曲线: JNI 本身 API 复杂，且涉及 Java 和原生代码之间的类型转换和错误处理，学习曲线较陡峭。
  • 调试难度: 跨语言调试通常比单一语言调试更复杂。
  • 开销: JNI 调用会有一定的性能开销（尽管通常可以忽略不计），尤其是在频繁调用小函数时。
  • 异常处理: JNI 中的错误处理需要手动检查 JNIEnv 的状态，并且不能直接从原生代码抛出 Java 异常。
  • 内存管理: 虽然 Rust 提供了内存安全，但在 Java 和 Rust 之间共享复杂数据结构时，需要谨慎处理内存所有权和生命周期。

总结

Rust FFI 和 JNI 的结合为 Java 应用程序提供了与高性能、内存安全的 Rust 代码无缝集成的强大机制。通过这种集成，开发者可以充分利用两种语言的优势，构建出既具备 Java 庞大生态系统和跨平台能力，又拥有 Rust 卓越性能和安全保障的现代化应用程序。虽然集成过程涉及一些复杂性，但通过仔细规划和使用像 jni 这样的 Rust crate，可以有效地管理这些挑战，并实现软件性能和可靠性的显著提升。

滚动至顶部