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

Question

我正在尝试将 HashMap 从 Java 转换为 Rust 并将其转换为内部对象，匹配数据类型等。Java 中的 HashMapHashMap<String, Object>可以Object是任何数据类型，包括其他数据类型HashMap<String, Object>。

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

正如您所看到的，我几乎没有取得任何进展，但作为第一遍，我只想返回 a String、Integer或 的字符串值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。结果是 a JValue，它可以返回一些原始类型。

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

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

然后如果需要的话我可以调用另一个方法。但据我所知，如果我愿意的话，我无法将其转换为 JString。然而，这也是迄今为止我知道如何从 JString 中获取 Rust 字符串的唯一方法，使用：

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

我这样做对吗？

如何将 JValue 转换为字符串？

我是否正确，我应该使用auto_local将 a 转换JValue为 a JObject，这将允许我再次调用它的方法？

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

编辑：

在 @Chris Jester-Young 的帮助下，我能够使 ajobj_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板条箱中，JObject和JString只是 JNIjobject和 的包装jstring。您可以使用该特征将 a “转换”JObject为a 。例如，或。但是，如果您完全不确定该对象是否实际上是字符串，则必须首先进行检查。JStringFromJString::from(my_jobject)my_jobject.into()JNIEnv::is_instance_of

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

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

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())
}