使用 Rust 语言编写 Java JNI 实现

前言

Rust 语言是近几年来编程语言界的新秀之子,因其严格的内存安全保障机制而备受众多程序员的青睐与推崇。而 Rust 语言除了可用于编写独立运行的二进制程序以外,亦可用于编写动态链接库并被第三方程序动态加载调用。笔者趁 Rust 学习途中就动手借助 jni crate 从而使用 Rust 语言通过 JNI 实现 Java 程序中的本地方法,并将此练手项目以及其编写过程一字不落地记录于此。

前置:相关环境的设置与必要软件的安装

JDK

JDK 是编写 Java 程序必要的开发组件。笔者使用的是 AdoptOpenJDK 版本 21 ,可在此处下载与你操作系统与架构相匹配的 AdoptOpenJDK 。详细安装过程受限于文章篇幅故略去,请自行检索安装方法。

笔者在此处贴出自己的 Java 版本信息以供读者对照:

$ /opt/adoptopenjdk-21.0.2+13/bin/java -version 
openjdk version "21.0.2" 2024-01-16 LTS
OpenJDK Runtime Environment Temurin-21.0.2+13 (build 21.0.2+13-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.2+13 (build 21.0.2+13-LTS, mixed mode, sharing)

Rust

既然要编写 Rust 代码,首先需要设置好 Rust 开发环境。笔者使用 Rustup 工具安装 Rust ,前往该链接可获取与你操作系统相符的安装工具或 shell 命令行。

笔者在此处贴出自己的 Rustup 版本信息以供读者对照:

$ rustup --version
rustup 1.27.0 (bbb9276d2 2024-03-08)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.76.0 (07dca489a 2024-02-04)`

Gradle

由于笔者使用 Gradle 作为 Java 代码的构建工具,故需先安装 Gradle 。 Gradle 已在其官方文档中给出不同操作系统上的安装方法,不过是英文版。考虑到读者的阅读需要,故记录一下自己的安装方法(Linux 系统上)。

Gradle 官方推荐采用 SDKMAN! 安装 Gradle ,笔者亦使用该方式来安装。前往该链接获取安装 shell 命令并执行(无需 sudo ,安装到用户主文件夹下):

$ curl -s "https://get.sdkman.io" | bash

等待 SDKMAN! 安装完成后,重启电脑或重新打开 shell ,运行:

$ sdk install gradle

稍等片刻, SDKMAN! 就自动安装好 Gradle 了。笔者在此处贴出自己的 Gradle 版本信息以供读者对照:

$ gradle --version                                  

------------------------------------------------------------
Gradle 8.7
------------------------------------------------------------

Build time:   2024-03-22 15:52:46 UTC
Revision:     650af14d7653aa949fce5e886e685efc9cf97c10

Kotlin:       1.9.22
Groovy:       3.0.17
Ant:          Apache Ant(TM) version 1.10.13 compiled on January 4 2023
JVM:          17.0.10 (Oracle Corporation 17.0.10+11-LTS-240)
OS:           Linux 6.8.2-zen2-1-zen amd64

准备:Java 程序的编写

新起一个文件夹作为项目的根文件夹,笔者起名为 rust-jni-demo

$ mkdir rust-jni-demo
$ cd rust-jni-demo

在项目根文件夹下另起一文件夹 java 作为 Java 代码部分的根目录:

$ mkdir java
$ cd java

我们对此项目的 Java 代码采用 Gradle 构建工具。在该目录中初始化 Gradle 的相关配置:

$ gradle init --use-defaults --type java-application

等待 Gradle 创建 Gradle Wrapper 与相关项目初始文件。完成后使用 Java IDE (笔者使用 IntelliJ IDEA )进入 app 目录并修改相关示例代码文件,编辑主类 App

/*
 * This source file was generated by the Gradle 'init' task
 */
package top.srcres.apps.rustjnidemo;

import java.io.File;
import java.nio.file.Path;

public class App {
    static void loadRustLibrary() {
        System.out.println(System.getProperty("java.library.path"));
        System.loadLibrary("rust_jni_demo");
    }

    static native String hello(String input);

    public static void main(String[] args) {
        loadRustLibrary();

        String output = hello("string from Java");
        System.out.println(output);
    }
}

其中 hello 方法即为我们要在 Rust 代码中实现的 native 方法。切回 Gradle 项目根目录并运行 ./gradlew build 先构建一下项目。

接下来需要编辑 app 目录下的 build.gradle.kts 文件,为 Gradle 添加生成 JNI 头文件的 Task ,在文件末尾加入:

val generateJniHeaders: Task by tasks.creating {
    val jniHeaderDir = file("src/main/generated/jni")

    group = "build"
    dependsOn(tasks.getByName("compileJava"))

    inputs.dir("src/main/java")
    outputs.dir(jniHeaderDir)

    doLast {
        val javaHome = Jvm.current().javaHome
        val javap = javaHome.resolve("bin").walk().firstOrNull { it.name.startsWith("javap") }?.absolutePath ?: error("javap not found")
        val javac = javaHome.resolve("bin").walk().firstOrNull { it.name.startsWith("javac") }?.absolutePath ?: error("javac not found")
        val buildDir = file("build/classes/java/main")
        val tmpDir = file("build/tmp/jvmJni").apply { mkdirs() }

        val bodyExtractingRegex = """^.+\Rpublic \w* ?class ([^\s]+).*\{\R((?s:.+))\}\R$""".toRegex()
        val nativeMethodExtractingRegex = """.*\bnative\b.*""".toRegex()

        println("Beginning to generate JNI headers.")
        println("javaHome is ${javaHome.absolutePath}")
        println("javap is $javap")
        println("javac is $javac")

        buildDir.walkTopDown()
                .filter { "META" !in it.absolutePath }
                .forEach { file ->
                    if (!file.isFile) return@forEach

                    val output = ByteArrayOutputStream().use {
                        project.exec {
                            commandLine(javap, "-private", "-cp", buildDir.absolutePath, file.absolutePath)
                            standardOutput = it
                        }.assertNormalExitValue()
                        it.toString()
                    }

                    val (qualifiedName, methodInfo) = bodyExtractingRegex.find(output)?.destructured ?: return@forEach

                    val lastDot = qualifiedName.lastIndexOf('.')
                    val packageName = qualifiedName.substring(0, lastDot)
                    val className = qualifiedName.substring(lastDot+1, qualifiedName.length)

                    val nativeMethods =
                            nativeMethodExtractingRegex.findAll(methodInfo).mapNotNull { it.groups }.flatMap { it.asSequence().mapNotNull { group -> group?.value } }.toList()
                    if (nativeMethods.isEmpty()) return@forEach

                    val source = buildString {
                        appendln("package $packageName;")
                        appendln("public class $className {")
                        for (method in nativeMethods) {
                            if ("()" in method) appendln(method)
                            else {
                                val updatedMethod = StringBuilder(method).apply {
                                    var count = 0
                                    var i = 0
                                    while (i < length) {
                                        if (this[i] == ',' || this[i] == ')') insert(i, " arg${count++}".also { i += it.length + 1 })
                                        else i++
                                    }
                                }
                                appendln(updatedMethod)
                            }
                        }
                        appendln("}")
                    }
                    val outputFile = tmpDir.resolve(packageName.replace(".", "/")).apply { mkdirs() }.resolve("$className.java").apply { delete() }.apply { createNewFile() }
                    outputFile.writeText(source)

                    println("Generating for ${outputFile.absolutePath} into ${jniHeaderDir.absolutePath}")
                    project.exec {
                        commandLine(javac, "-h", jniHeaderDir.absolutePath, outputFile.absolutePath)
                    }.assertNormalExitValue()
                }
    }
}

保存文件后切回 Gradle 项目根目录,运行刚才新添加的 Task , ./gradlew generateJniHeaders 。完成后可在 app/src/main/generated/jni 目录下找到生成的 JNI 头文件,应该能在其中看到如下内容:

/*
 * Class:     top_srcres_apps_rustjnidemo_App
 * Method:    hello
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_top_srcres_apps_rustjnidemo_App_hello
  (JNIEnv *, jclass, jstring);

自此 Java 代码部分编写完毕,接下来使用 Rust 代码实现这个预留的 native 方法。

实现:Rust 动态链接库的编写

切回到整体项目的根目录( java 的父目录),另起一目录用以存放 Rust 代码:

$ mkdir rust
$ cargo new --name rust-jni-demo rust

注意此处我们用 Rust 自带的包管理器 Cargo 创建了 rust 目录并自动地完成了相应的初始化工作,并将这个 Rust Crate 名称指定为 rust-jni-demo 。修改该目录中的 Cargo.toml 文件,添加依赖 cargo 并指定 Crate 类型为动态链接库:

[dependencies]
jni = "0.21.1"

[lib]
crate-type = ["cdylib"]

进入 src 目录,删掉默认的 main.rs 文件,新建 lib.rs 文件,在此文件中编写 native 方法的实现:

use jni::JNIEnv;
use jni::objects::{JClass, JObject, JString, JValue};
use jni::sys::{jint, jlong, jstring};
use std::thread;
use std::time::Duration;

fn create_rust_string(src: &str) -> String {
    format!("Rust-created string, {}", src)
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_hello<'a>(
    mut env: JNIEnv<'a>,
    _: JClass<'a>,
    input: JString<'a>
) -> jstring {
    let input: String = env.get_string(&input).expect("Failed to get Java string.").into();
    let output = env.new_string(create_rust_string(&input)).expect("Failed to create Rust string.");
    output.into_raw()
}

回到 Rust Cargo 的根目录,构建 release 版本的 Cargo :

$ cargo build --release

构建完成后,在 target/release 目录下应能找到构建生成的动态链接库(笔者在 Linux 系统上构建生成 librust_jni_demo.so )。接下来需要让 Java 程序加载这个动态链接库从而调用其对于 native 方法的实现。

回到 Java 代码目录中,编辑 app/build.gradle.kts 文件,在 application 块中加入运行 Java 程序的 JVM 参数:

application {
    // Define the main class for the application.
    mainClass = "top.srcres.apps.rustjnidemo.App"
    applicationDefaultJvmArgs = listOf(
            "-Djava.library.path=../../rust/target/release/"
    )
}

运行 ./gradlew run , Java 程序出现以下输出,代表成功调用 Rust 代码所编写的 native 实现。

Rust-created string, string from Java

后续:添加更多不同功能的 native 方法并实现

我们为 Java 程序主类 App 添加更多的静态 native 方法:

    static int testInt;
    static String testString;
    static String testStringFromRust;

    static native String hello(String input);
    static native int helloInt(int input);
    static native int helloFromTestIntField();
    static native String helloFromTestStringField();
    static native void modifyTestStringFromRust(String input);
    static String callFromRust(String input) {
        System.out.println("Method callFromRust was invoked!");
        return "Java-side received: " + input;
    }
    static native String actCallFromRust(String input);
    static native void delayInRust(long timeMillis);

并在 main 方法中予以调用:

    public static void main(String[] args) {
        loadRustLibrary();

        String output = hello("string from Java");
        System.out.println(output);

        int outputInt = helloInt(114514);
        System.out.println(outputInt);

        testInt = 514;
        System.out.println(helloFromTestIntField());

        testString = "String static field from Java";
        System.out.println(helloFromTestStringField());

        modifyTestStringFromRust("string from Java #2");
        System.out.println(testStringFromRust);

        System.out.println("actCallFromRust result: " + actCallFromRust("string from Java #3"));

        System.out.println("Delay in Rust for 2 seconds...");
        delayInRust(2000);
        System.out.println("Delay done.");
    }

转到 Rust 代码中实现这些 native 方法:

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_helloInt<'a>(
    _: JNIEnv<'a>,
    _: JClass<'a>,
    input: jint
) -> jint {
    input + 1919810
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_helloFromTestIntField<'a>(
    mut env: JNIEnv<'a>,
    class: JClass<'a>
) -> jint {
    let testInt = env.get_static_field(&class, "testInt", "I")
        .expect("Failed to get static field testInt")
        .i()
        .expect("Failed to convert testInt into jint");
    testInt + 114
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_helloFromTestStringField<'a>(
    mut env: JNIEnv<'a>,
    class: JClass<'a>
) -> jstring {
    let testStringObj = env.get_static_field(&class, "testString", "Ljava/lang/String;")
        .expect("Failed to get static field testString")
        .l()
        .expect("Failed to convert testString into JObject");
    let testString: String = env.get_string(&JString::from(testStringObj))
        .expect("Failed to get the value of testString")
        .into();
    let output = env.new_string(create_rust_string(&testString)).expect("Failed to create Rust string.");
    output.into_raw()
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_modifyTestStringFromRust<'a>(
    mut env: JNIEnv<'a>,
    class: JClass<'a>,
    input: JString<'a>
) {
    let inputStr: String = env.get_string(&input).expect("Failed to receive the argument: input").into();
    let testStringFromRust = env.new_string(create_rust_string(&inputStr)).expect("Failed to create Rust string.");
    let testStringFromRustObj = JObject::from(testStringFromRust);
    let testStringFromRustId = env.get_static_field_id(&class, "testStringFromRust", "Ljava/lang/String;")
        .expect("Failed to get the ID of static field testStringFromRust");
    env.set_static_field(&class, &testStringFromRustId, JValue::from(&testStringFromRustObj))
        .expect("Failed to set static field testStringFromRust");
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_actCallFromRust<'a>(
    mut env: JNIEnv<'a>,
    class: JClass<'a>,
    input: JString<'a>
) -> jstring {
    let inputStr: String = env.get_string(&input).expect("Failed to receive the argument: input").into();
    let testStringFromRust = env.new_string(create_rust_string(&inputStr)).expect("Failed to create Rust string.");
    let testStringFromRustObj = JObject::from(testStringFromRust);
    let callFromRustResult = env.call_static_method(&class, "callFromRust", "(Ljava/lang/String;)Ljava/lang/String;", &[JValue::from(&testStringFromRustObj)])
        .expect("Failed to invoke static method callFromRust");
    let callFromRustResultObj = callFromRustResult.l().expect("Failed to convert the method result into JObject.");
    JString::from(callFromRustResultObj).into_raw()
}

#[allow(non_snake_case)]
#[no_mangle]
pub extern "system" fn Java_top_srcres_apps_rustjnidemo_App_delayInRust<'a>(
    _: JNIEnv<'a>,
    _: JClass<'a>,
    input: jlong
) {
    let inputU = u64::try_from(input).expect("Attempting to call delayInRust with negative millisecond duration.");
    thread::sleep(Duration::from_millis(inputU));
}

先构建 Rust 动态链接库 cargo build --release ,再构建并运行 Java 程序 ./gradlew run 。将会得到如下输出:

../../rust/target/release/
Rust-created string, string from Java
2034324
628
Rust-created string, String static field from Java
Rust-created string, string from Java #2
Method callFromRust was invoked!
actCallFromRust result: Java-side received: Rust-created string, string from Java #3
Delay in Rust for 2 seconds...
Delay done.

完整项目

完整的项目源码已上传至 GitHub 仓库 ,使用 MIT 协议开源。由于时间仓促没能就代码细节具体解释实现原理,读者可自行前往阅读研究。

热门相关:萌妻鲜嫩:神秘老公晚上见   淫乱家教   农家小地主   童养媳之桃李满天下   狂仙