将未知 Java 类型转换为 Rust 类型

Question

我正在尝试从 Java 中获取一个 HashMap 到 Rust 并将其转换为一个内部对象，匹配数据类型和所有。 java 中的 HashMap 是一个 HashMap<String, Object>，其中 Object 可以是任何数据类型，包括另一个 HashMap<String, Object>.

我很难确定 JObject 是什么类型的对象，而且我不知道如何将 JObject 转换为 JString 之类的东西。

如您所见，我几乎没有使用它，但作为第一遍，我只想 return String、[=22= 的字符串值]，或 Date（其中 Date 将是 Date.getTime() 的字符串值）。

static DATE_CLASS: &str = "java/util/Date";
static INTEGER_CLASS: &str = "java/lang/Integer";
static STRING_CLASS: &str = "java/lang/String";

fn get_string_value(env: &JNIEnv, obj: JObject) -> String {
    let ret = String::new();

    if env.is_instance_of(obj, STRING_CLASS).unwrap() {
        let ret2 = env.call_method(obj, "toString", "()Ljava/lang/String;", &[]).unwrap();
        // Got a JValue- now what?
    }

    if env.is_instance_of(obj, INTEGER_CLASS).unwrap() {
        let ret2 = env.call_method(obj, "toString", "()Ljava/lang/String;", &[]).unwrap();
        // Got a JValue- now what?
    }

    if env.is_instance_of(obj, INTEGER_CLASS).unwrap() {
        let ret2 = env.call_method(obj, "getTime", "()Ljava/lang/String;", &[]).unwrap();
        // Got a JValue- now what?
    }

    ret
}

我认为我应该这样做的方式（但如果不是，请纠正我），是检查JObject是否是任何其中类按其完全限定的路径。一旦我知道它们是什么类型，我就可以使用 env.call_method 调用它们的方法。结果是一个JValue，它可以return一些原始类型。

我假设我应该使用这些，除非我期望另一个对象被 returned，在这种情况下我会使用-

let message_ref = env.auto_local(ret2).as_obj();

然后我可以根据需要调用另一个方法。但据我所知，如果我愿意，我不能将其转换为 JString。然而，到目前为止，这也是我知道如何从 JString 中获取生锈字符串的唯一方法，使用：

let s: String = env.get_string(a_j_string).expect("Couldn't get java string").into();

我这样做对吗？

如何将 JValue 转换为字符串？

我应该使用 auto_local 将 JValue 转换为 JObject，这样我就可以再次调用方法了吗？

如果我应该使用原始类型 jchar 来获取 toString 的值——我该如何将其转换为 &str 或 String？

编辑：

在@Chris Jester-Young 的帮助下，我能够同时使用 jobj_to_string 和 jobj_to_int 函数。

static INTEGER_CLASS: &str = "java/lang/Integer";
static STRING_CLASS: &str = "java/lang/String";

fn get_liquid_value(env: &JNIEnv, obj: JObject) -> LiquidValue {
    let mut value = LiquidValue::Nil;

    if env.is_instance_of(obj, STRING_CLASS).unwrap() {
        match jobj_to_string(env, obj) {
            Some(str) => {
                value = LiquidValue::Scalar(LiquidScalar::from(str));
            },
            None => {}
        }
    }

    if env.is_instance_of(obj, INTEGER_CLASS).unwrap() {
        match jobj_to_i32(env, obj) {
            Some(int) => {
                value = LiquidValue::Scalar(LiquidScalar::from(int));
            },
            None => {}
        }
    }

    value
}

fn jobj_to_string(env: &JNIEnv, obj: JObject) -> Option<String> {
    let mut result = Option::None;

    match env.call_method(obj, "toString", "()Ljava/lang/String;", &[]) {
        Result::Ok(jvalue) => {
            match jvalue.l() {
                Result::Ok(jobject) => {
                    let string = String::from(env.get_string(jobject.into()).unwrap().to_str().unwrap());
                    result = Option::Some(string);
                },
                _ => {}
            }
        },
        _ => {}
    };

    result
}

fn jobj_to_i32(env: &JNIEnv, obj: JObject) -> Option<i32> {
    let mut result = Option::None;

    match env.call_method(obj, "intValue", "()I", &[]) {
        Ok(jvalue) => {
            match jvalue.i() {
                Ok(int) => {
                    result = Option::Some(int.to_owned());
                },
                _ => {}
            }
        },
        _ => {}
    }

    result
}

Answer 1

在 jni crate 中，JObject 和 JString 只是 JNI 的 jobject 和 jstring 的包装器。您可以使用 From 特性将 JObject“转换”为 JString。例如，JString::from(my_jobject) 或 my_jobject.into()。但是，如果您不确定对象是否真的是字符串，则必须先进行 JNIEnv::is_instance_of 检查。

关于你关于 JValue 的问题，toString 的结果是一个字符串，在 JVM 世界中，它是一个对象类型，而不是原始类型。所以你可以只使用 JValue::l 访问器（据我所知你不需要使用 auto_local ）。由于我们知道结果是一个字符串，你可以直接将结果转换为 JString（如上所述），然后调用 JNIEnv::get_string 得到一个 JavaStr 对象，你可以使用 From 特征转换为 Rust 字符串。

将所有内容放在一起，我们得到以下内容（未测试，但至少对我来说是编译的）：

fn get_string_value(env: &JNIEnv, obj: JObject<'_>) -> Result<String> {
    let result = env.call_method(obj, "toString", "()Ljava/lang/String;", &[])?.l()?;
    Ok(env.get_string(result.into())?.into())
}

将未知 Java 类型转换为 Rust 类型

Converting unknown Java types to Rust types

java

java-native-interface

rust