Java 是一个需要运作在 JVM 上的编程语言,因此性能会比原生(native)程序还要来得差一些。不过对于一些比较需要花费硬件资源的运算(例如图像处理、声音处理),我们还是可以透过 Java 提供的 JNI (Java Native Interface)来链接并使用原生函数库提供的功能来完成。Rust 的函数库也可以透过 JNI 来调用,在这篇文章中,会介绍如何把任意现有的 Rust 函数库拿进 Java 编程语言中使用。

ShortCrypt

ShortCrypt 是笔者开发的跨编程语言的数据加解密函数库,其介绍文章的网址如下:

在本篇文章中,将会尝试把用 Rust 编程语言实作的 ShortCrypt 函数库加上 JNI,使其能够在 Java 编程语言中使用。

ShortCrypt JNI

创建项目目录

要将现有的 Rust 函数库加上 JNI,不一定需要去修改原本 Rust 函数库程序项目的代码。我们同样可以先创建出一个新的 Cargo 函数库项目,名为 short-crypt-jni。

指令如下:

cargo new --lib short-crypt-jni

引用 short-crypt 套件(crate)

编辑 Cargo.toml,在 [dependencies] 区块下加上:

short-crypt = "*"

引用 jni 套件(crate)

为了能够让我们用 Rust 编程语言撰写 JNI 程序,就需要引用 jni 这个 crate。

编辑 Cargo.toml,在 [dependencies] 区块下加上:

jni = "*"

Java 程序实作

是的,您没看错标题。在开始把 ShortCrypt 的 Rust 函数库加上 JNI 前,我们应该要先规划好 Java 程序中哪些地方需要使用到由 Rust 编程语言实作的方法或是函数,这些方法都需要先使用 Java 的 native 修饰子来进行声明,并且使用 System 类别下的 loadLibrary 方法来读入指定名称的动态函数库。

我们在 Cargo 程序项目的根目录下,添加一个 java 目录,在这个目录中再添加一个 Java 源代码文件,文件名为 ShortCrypt.java。内容如下:

import java.io.IOException;

public class ShortCrypt {
 
    // TODO -----Static Initializer-----
 
	static {
		System.loadLibrary("short_crypt_jni");
	}
	
	// TODO -----Static Classes-----
	
	public static class Cipher {
	    public final byte base;
	    public final byte[] body;
	    
	    public Cipher(final byte base, final byte[] body) {
	        this.base = base;
	        this.body = body;
	    }
	}
	
	public static class DecryptException extends IOException {
	    public DecryptException(final String message) {
	        super(message);
	    }
	    
	    public DecryptException(final String message, final Throwable cause) {
	        super(message, cause);
	    }
	}
	
	// TODO -----Static Native Methods-----
 
	private static native long sc_new(final String key);
	
	// TODO -----Object Constants-----
	
	private final long sc;
	
	// TODO -----Constructors-----
	
	public ShortCrypt(final String key) {
	    this.sc = sc_new(key);
	}
	
	// TODO -----Object Native Methods-----
	
	public native Cipher encryptString(final String plaintext);
	
	public native Cipher encryptBinary(final byte[] plaintext);
	
	public native byte[] decryptToBinary(final Cipher cipher) throws DecryptException;
	
	public native String decryptToString(final Cipher cipher) throws DecryptException;
	
	public native String encryptStringToURLComponent(final String data);
	
	public native String encryptBinaryToURLComponent(final byte[] data);
	
	public native byte[] decryptURLComponentToBinary(final String urlComponent);
	
	public native String decryptURLComponentToString(final String urlComponent);
	
	public native String encryptStringToQRCodeAlphanumeric(final String data);
	
	public native String encryptBinaryToQRCodeAlphanumeric(final byte[] data);
	
	public native byte[] decryptQRCodeAlphanumericToBinary(final String qrCodeAlphanumeric);
	
	public native String decryptQRCodeAlphanumericToString(final String qrCodeAlphanumeric);
	
	public native void close();
}

以上程序中,比较需要特别注意的部份有以下几点:

  • 如果是使用 Unix-like 系统 System.loadLibrary("short_crypt_jni") 会去链接的函数库文件名为 libshort_crypt_jni.so;如果是使用 Windows 系统,它会去链接的函数库文件名为 short_crypt_jni.dll;如果是使用 macOS 系统,它会去链接的函数库文件名为 libshort_crypt_jni.dylib。
  • 在 Rust 程序中可以直接访问到 Java 程序的类别,因此要创建 Cipher 类别的对象实体并回传是可行的。
  • 在 Rust 程序中可以抛出 Java 的例外。
  • Java 的 long 类型可以当作指针。
  • 由于 Rust 的 ShortCrypt 结构实体不是在 Java 程序中创建出来的,因此它并不会被垃圾回收,我们必须提供额外的 close 方法来清除掉不使用的 ShortCrypt 结构实体。

使用 javac 创建 C/C++ 的标头档(*.h)

javac 是 Java 编程语言的编译工具,它也可以用来把 Java 程序中所有用到 native 关键字修饰的方法,转成 C/C++ 的标头档(.h 档)。

指令的用法如下:

javac path/to/java-file.java -h path/to/header-output-folder

例如要编译 java/ShortCrypt.java 并且将标头档产生至 java 目录中的话,指令如下:

javac java/ShortCrypt.java -h java

产生出来的标头档的路径为 java/ShortCrypt.h,内容如下:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class ShortCrypt */

#ifndef _Included_ShortCrypt
#define _Included_ShortCrypt
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     ShortCrypt
 * Method:    sc_new
 * Signature: (Ljava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_ShortCrypt_sc_1new
  (JNIEnv *, jclass, jstring);

/*
 * Class:     ShortCrypt
 * Method:    encryptString
 * Signature: (Ljava/lang/String;)LShortCrypt/Cipher;
 */
JNIEXPORT jobject JNICALL Java_ShortCrypt_encryptString
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    encryptBinary
 * Signature: ([B)LShortCrypt/Cipher;
 */
JNIEXPORT jobject JNICALL Java_ShortCrypt_encryptBinary
  (JNIEnv *, jobject, jbyteArray);

/*
 * Class:     ShortCrypt
 * Method:    decryptToBinary
 * Signature: (LShortCrypt/Cipher;)[B
 */
JNIEXPORT jbyteArray JNICALL Java_ShortCrypt_decryptToBinary
  (JNIEnv *, jobject, jobject);

/*
 * Class:     ShortCrypt
 * Method:    decryptToString
 * Signature: (LShortCrypt/Cipher;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_decryptToString
  (JNIEnv *, jobject, jobject);

/*
 * Class:     ShortCrypt
 * Method:    encryptStringToURLComponent
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_encryptStringToURLComponent
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    encryptBinaryToURLComponent
 * Signature: ([B)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_encryptBinaryToURLComponent
  (JNIEnv *, jobject, jbyteArray);

/*
 * Class:     ShortCrypt
 * Method:    decryptURLComponentToBinary
 * Signature: (Ljava/lang/String;)[B
 */
JNIEXPORT jbyteArray JNICALL Java_ShortCrypt_decryptURLComponentToBinary
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    decryptURLComponentToString
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_decryptURLComponentToString
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    encryptStringToQRCodeAlphanumeric
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_encryptStringToQRCodeAlphanumeric
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    encryptBinaryToQRCodeAlphanumeric
 * Signature: ([B)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_encryptBinaryToQRCodeAlphanumeric
  (JNIEnv *, jobject, jbyteArray);

/*
 * Class:     ShortCrypt
 * Method:    decryptQRCodeAlphanumericToBinary
 * Signature: (Ljava/lang/String;)[B
 */
JNIEXPORT jbyteArray JNICALL Java_ShortCrypt_decryptQRCodeAlphanumericToBinary
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    decryptQRCodeAlphanumericToString
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_ShortCrypt_decryptQRCodeAlphanumericToString
  (JNIEnv *, jobject, jstring);

/*
 * Class:     ShortCrypt
 * Method:    close
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_ShortCrypt_close
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

我们等等要参考这个标头档的内容来撰写 Rust 程序。

Rust 程序实作

在 src/lib.rs 文件中撰写以下程序:

use std::ptr;

use jni::JNIEnv;
use jni::objects::{JClass, JObject, JString, JValue};
use jni::sys::{jlong, jobject, jbyteArray, jstring};

use short_crypt::{ShortCrypt, Cipher};

#[inline]
fn throw_decrypt_exception<S: AsRef<str>>(env: &JNIEnv, msg: S) {
    let decrypt_exception_class = env.find_class("ShortCrypt$DecryptException").expect("Should get the DecryptException class.");

    env.throw_new(decrypt_exception_class, msg).expect("Should throw an DecryptException.");
}

#[inline]
fn throw_exception<S: AsRef<str>>(env: &JNIEnv, msg: S) {
    let runtime_exception_class = env.find_class("java/lang/RuntimeException").expect("Should get the RuntimeException class.");

    env.throw_new(runtime_exception_class, msg).expect("Should throw an RuntimeException.");
}

#[inline]
fn ensure_ptr_not_null_or_throw_exception<S: AsRef<str>>(env: &JNIEnv, ptr: jlong, msg: S) -> bool {
    if ptr == 0 {
        throw_exception(env, msg);

        false
    } else {
        true
    }
}

#[inline]
fn try_to_get_short_crypt_or_throw_exception<'a>(env: &JNIEnv, object: JObject) -> Option<&'a ShortCrypt> {
    let sc_ptr = env.get_field(object, "sc", "J").expect("Should get a long value.").j().expect("Should get a long value.");

    if ensure_ptr_not_null_or_throw_exception(env, sc_ptr, "This ShortCrypt object is closed.") {
        Some(unsafe {
            &*(sc_ptr as *const ShortCrypt)
        })
    } else {
        None
    }
}

#[inline]
fn get_cipher_or_throw_exception(env: &JNIEnv, cipher: JObject) -> Option<Cipher> {
    if cipher.is_null() {
        throw_exception(&env, "The cipher is null.");

        None
    } else {
        let base = env.get_field(cipher.clone(), "base", "B").expect("Should get a byte.").b().expect("Should get a byte.");

        let body = env.get_field(cipher, "body", "[B").expect("Should get a byte array.").l().expect("Should get a byte array.");

        let body = env.convert_byte_array(body.into_inner()).expect("Should get a byte array.");

        Some((base as u8, body))
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_sc_1new(env: JNIEnv, _class: JClass, key: JString) -> jlong {
    let key: String = env.get_string(key).expect("Should get a string.").into();

    let sc = ShortCrypt::new(key);

    Box::into_raw(Box::new(sc)) as jlong
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptString(env: JNIEnv, object: JObject, plaintext: JString) -> jobject {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let plaintext: String = env.get_string(plaintext).expect("Should get a string.").into();

            let sc_cipher = sc.encrypt(&plaintext);

            let cipher_class = env.find_class("ShortCrypt$Cipher").expect("Should get the Cipher class.");

            let body = env.byte_array_from_slice(sc_cipher.1.as_slice()).unwrap();

            let cipher = env.new_object(cipher_class, "(B[B)V", &[JValue::from(sc_cipher.0), JValue::from(JObject::from(body))]).expect("Should create a Cipher instance.");

            cipher.into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptBinary(env: JNIEnv, object: JObject, plaintext: jbyteArray) -> jobject {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let plaintext = env.convert_byte_array(plaintext).unwrap();

            let sc_cipher = sc.encrypt(&plaintext);

            let cipher_class = env.find_class("ShortCrypt$Cipher").expect("Should get the Cipher class.");

            let body = env.byte_array_from_slice(sc_cipher.1.as_slice()).unwrap();

            let cipher = env.new_object(cipher_class, "(B[B)V", &[JValue::from(sc_cipher.0), JValue::from(JObject::from(body))]).expect("Should create a Cipher instance.");

            cipher.into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptToBinary(env: JNIEnv, object: JObject, cipher: JObject) -> jbyteArray {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            match get_cipher_or_throw_exception(&env, cipher) {
                Some(cipher) => match sc.decrypt(&cipher) {
                    Ok(data) => {
                        env.byte_array_from_slice(data.as_slice()).unwrap()
                    }
                    Err(message) => {
                        throw_decrypt_exception(&env, message);

                        ptr::null_mut()
                    }
                }
                None => ptr::null_mut()
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptToString(env: JNIEnv, object: JObject, cipher: JObject) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            match get_cipher_or_throw_exception(&env, cipher) {
                Some(cipher) => match sc.decrypt(&cipher) {
                    Ok(data) => {
                        env.new_string(String::from_utf8_lossy(data.as_slice())).unwrap().into_inner()
                    }
                    Err(message) => {
                        throw_decrypt_exception(&env, message);

                        ptr::null_mut()
                    }
                }
                None => ptr::null_mut()
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptStringToURLComponent(env: JNIEnv, object: JObject, data: JString) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let data: String = env.get_string(data).expect("Should get a string.").into();

            let result = sc.encrypt_to_url_component(&data);

            env.new_string(result).unwrap().into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptBinaryToURLComponent(env: JNIEnv, object: JObject, data: jbyteArray) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let data = env.convert_byte_array(data).unwrap();

            let result = sc.encrypt_to_url_component(&data);

            env.new_string(result).unwrap().into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptURLComponentToBinary(env: JNIEnv, object: JObject, url_component: JString) -> jbyteArray {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let url_component: String = env.get_string(url_component).expect("Should get a string.").into();

            match sc.decrypt_url_component(&url_component) {
                Ok(data) => {
                    env.byte_array_from_slice(data.as_slice()).unwrap()
                }
                Err(message) => {
                    throw_decrypt_exception(&env, message);

                    ptr::null_mut()
                }
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptURLComponentToString(env: JNIEnv, object: JObject, url_component: JString) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let url_component: String = env.get_string(url_component).expect("Should get a string.").into();

            match sc.decrypt_url_component(&url_component) {
                Ok(data) => {
                    env.new_string(String::from_utf8_lossy(data.as_slice())).unwrap().into_inner()
                }
                Err(message) => {
                    throw_decrypt_exception(&env, message);

                    ptr::null_mut()
                }
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptStringToQRCodeAlphanumeric(env: JNIEnv, object: JObject, data: JString) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let data: String = env.get_string(data).expect("Should get a string.").into();

            let result = sc.encrypt_to_qr_code_alphanumeric(&data);

            env.new_string(result).unwrap().into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_encryptBinaryToQRCodeAlphanumeric(env: JNIEnv, object: JObject, data: jbyteArray) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let data = env.convert_byte_array(data).unwrap();

            let result = sc.encrypt_to_qr_code_alphanumeric(&data);

            env.new_string(result).unwrap().into_inner()
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptQRCodeAlphanumericToBinary(env: JNIEnv, object: JObject, qr_code_alphanumeric: JString) -> jbyteArray {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let qr_code_alphanumeric: String = env.get_string(qr_code_alphanumeric).expect("Should get a string.").into();

            match sc.decrypt_qr_code_alphanumeric(&qr_code_alphanumeric) {
                Ok(data) => {
                    env.byte_array_from_slice(data.as_slice()).unwrap()
                }
                Err(message) => {
                    throw_decrypt_exception(&env, message);

                    ptr::null_mut()
                }
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_decryptQRCodeAlphanumericToString(env: JNIEnv, object: JObject, qr_code_alphanumeric: JString) -> jstring {
    match try_to_get_short_crypt_or_throw_exception(&env, object) {
        Some(sc) => {
            let qr_code_alphanumeric: String = env.get_string(qr_code_alphanumeric).expect("Should get a string.").into();

            match sc.decrypt_qr_code_alphanumeric(&qr_code_alphanumeric) {
                Ok(data) => {
                    env.new_string(String::from_utf8_lossy(data.as_slice())).unwrap().into_inner()
                }
                Err(message) => {
                    throw_decrypt_exception(&env, message);

                    ptr::null_mut()
                }
            }
        }
        None => {
            ptr::null_mut()
        }
    }
}

#[no_mangle]
#[allow(non_snake_case)]
pub extern fn Java_ShortCrypt_close(env: JNIEnv, object: JObject) {
    let sc_ptr = env.get_field(object.clone(), "sc", "J").expect("Should get a long value.").j().expect("Should get a long value.");

    if ensure_ptr_not_null_or_throw_exception(&env, sc_ptr, "This ShortCrypt object has been closed.") {
        unsafe {
            drop(Box::from_raw(sc_ptr as *mut ShortCrypt));
        }

        env.set_field(object, "sc", "J", JValue::from(0i64)).expect("Should set a long value.");
    }
}

以上程序中,比较需要特别注意的部份有以下几点:

  • 由于 Rust 会自动在拥有者被消灭时,去 drop 其所拥有的实体。所以我们在堆栈中产生出来的 ShortCrypt 结构实体,要先利用 Box 结构体移到堆积上,接着再用 Box 结构体的 into_raw 关联函数将其转成指针(long 型态),存在 Java 的对象字段中。
  • 为了避免内存泄漏(memory leak),所以要提供一个 close 函数,并在这个函数中透过 Box 结构体的 from_raw 关联函数,将指针转回 Box 结构实体再 drop 掉,来释放保存在堆积中的 ShortCrypt 结构实体。
  • JNI 函数用到的 #[no_mangle] 属性和 pub extern 关键字,是为了要保留函数名称,确保 Java 程序可以调用得到。
  • jni 这个 crate 中,有许多 sys::jstring 和 objects::JString、sys::jobject 和 objects::JObject 等名称类似但大小写不同的类型,它们是不同的类型,有用大写的表示 jni 这个 crate 有为它提供专门的结构来处理,只有用小写的表示它只有做原生 JNI 类型的对应。不过不管有没有大写,它们都可以被用在 JNI 函数的参数或是回传值类型上。建议回传值类型都用只有小写的那些,免得还要处理生命周期的问题。
  • Rust 标准函数库的 ptr 模块提供的 null_mut 函数,可以让 JNI 函数回传 null。(只不过 JNI 函数的回传值类型要用小写的那些)
  • 在 Rust 程序中抛出 Java 的例外,并不会立刻中断之后程序的运行,所以要将已进入抛出例外状态的流程区分开来。

关于 Java 的签名(signature)用字符串表示的方式,可以参考以下表格:

种类 签名字符串
boolean Z
byte B
char C
short S
int I
long J
float F
double D
类别 L 类别路径;
数组 [类型名称
方法 (参数类型签名)回传值类型签名

例如这个方法:

long f (int n, String s, int[] arr);

其签名的字符串为:

(ILjava/lang/String;[I)J

在 JNI 中,要使用字段或是方法时几乎都需要先透过签名字符串来寻找,所以这个格式一定要了解,才有办法开发 JNI 程序。

编译函数库

由于 Rust 的函数库预设的格式为 .rlib,并非 C/C++ 使用的 .a、.so、.dll、.dylib 等。为了要编译出 Java 语言能够加载的函数库,必须要去修改 Cargo 的设置档,在 [lib] 区块中,加上 crate-type 项目,将其的值设置为 ["cdylib"]。如下:

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

如果不设置 crate-type,Cargo 会根据 src 目录中有无 lib.rs 文件来决定要不要加入 rlib,也就是 crate-type = ["rlib"]。

在 crate-type 项目加入 cdylib,可以使 Cargo 在编译程序项目时,将能用在 C/C++ 程序的动态函数库也跟着编译出来。

将设置档修改好后,运行 cargo build --release 指令,就可以在 target/release 目录中找到动态函数库文件啦!目标平台如果是 Linux 的话,就会看到 libshort_crypt_jni.so 文件。

链接函数库

在使用 java 指令运行 Java 程序时,如果要加载动态函数库,就要在 java 指令的后面紧接 -Djava.library.path=/path/to/library-folder 参数。

我们可以在 Cargo 程序项目根目录的 java 目录中再添加一个 ShortCryptExample.java 文件来试试我们的 ShortCrypt.java 能不能正常被使用。ShortCryptExample.java 文件内容如下:

public class ShortCryptExample {
    public static void main(final String[] args) throws Exception {
        final ShortCrypt sc = new ShortCrypt("magickey");
            
        final String urlComponent = sc.encryptStringToURLComponent("articles");
            
        System.out.println(urlComponent);
        System.out.println(sc.decryptURLComponentToString(urlComponent));

        sc.close();
    }
}

接着将终端机的工作目录移动到 java 目录中,运行以下指令来编译程序:

javac ShortCrypt.java ShortCryptExample.java

然后用以下指令来运行 ShortCryptExample.class:

java -Djava.library.path=../target/release ShortCryptExample

这边要注意的是,-D 参数的位置一定要在文件输入的参数之前,否则会没有效果。

ShortCryptExample.class 的运行结果如下:

2E87Wx52-Tvo
articles

在 Android 上使用 JNI

交叉编译

我们可以借由交叉编译,来编译出能在 Android 系统上加载的动态函数库。有关于交叉编译 Rust 程序的方式,可以参考这篇文章:

链接函数库

Android 上的 Java 程序不像一般 Windows、Linux、macOS 等操作系统上的 Java 程序一样要使用 java 指令工具来运行,所以也就不用弄什么 -Djava.library.path 参数。我们只要将针对不同 CPU 架构编译出来的动态函数库(.so 档),分类放在 Android Studio 程序项目内的 app/src/main/jniLibs 目录下的子目录当中就好了。

子目录都是用 Android ABI 来命名,列表如下:

目录名称 支持的指令集 对应的 Rust 编译目标(cross)
armeabi-v7a armeabi
Thumb-2
VFPv3-D16
armv7-linux-androideabi
arm64-v8a AArch64
aarch64-linux-android
x86 x86 (IA-32)
MMX
SSE/2/3
SSSE3
i686-linux-android
x86_64 x86-64
MMX
SSE/2/3
SSSE3
SSE4.1, 4.2
POPCNT
x86_64-linux-android