Rust 与 Kotlin：优雅的数据传输与多态序列化实践

在现代软件开发中，尤其是在系统编程和移动应用领域，实现不同语言之间的数据交换至关重要。Rust 和 Kotlin 都以其高性能和安全性著称，提供了强大的多态序列化机制，能够确保数据结构在不同语言间的一致性和可维护性。本文将通过一个示例，展示如何在 Rust 和 Kotlin 中定义和处理多态消息，确保它们之间的无缝互操作。

定义消息结构

我们希望构建一个多态消息系统，包含两种类型的消息：

• LedMessage：控制 LED 的整数值。
• TextMessage：发送一条文本消息。

Rust 实现

Rust 使用 serde 库进行序列化和反序列化。通过使用 #[serde(tag = "type")] 属性，我们可以根据 type 字段区分不同的消息类型。

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
enum Message {
    #[serde(rename = "led")]
    Led(LedMessage),
    #[serde(rename = "text")]
    Text(TextMessage),
    #[serde(other)]
    Unknown,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct LedMessage {
    value: i32,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct TextMessage {
    text: String,
}

impl Message {
    fn to_json(&self) -> serde_json::Result<String> {
        serde_json::to_string(self)
    }

    fn from_str(src: &str) -> serde_json::Result<Self> {
        serde_json::from_str(src)
    }
}

fn test() {
    let led_message = Message::Led(LedMessage { value: 33 });
    let encoded = led_message.to_json().unwrap();
    println!("{}", encoded);

    match Message::from_str("{\"text\":\"hello text\",\"type\":\"text\"}").unwrap() {
        Message::Led(led_message) => {
            println!("收到 LedMessage：{}", led_message.value)
        }
        Message::Text(text_message) => {
            println!("收到 TextMessage：{}", text_message.text)
        }
        Message::Unknown => {
            println!("未知的消息类型")
        }
    }
}

在这个实现中，type 字段用于区分不同的消息类型，serde 会根据该字段自动选择合适的枚举变体进行反序列化。

Kotlin 实现

Kotlin 使用 kotlinx.serialization 库处理多态序列化。通过自定义序列化器，我们可以根据 type 字段动态选择合适的反序列化器。

import kotlinx.serialization.*
import kotlinx.serialization.json.*

object MessageSerializer : JsonContentPolymorphicSerializer<Message>(Message::class) {
    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<Message> {
        val type = element.jsonObject["type"]!!.jsonPrimitive.content
        return when (type) {
            "led" -> Message.LedMessage.serializer()
            "text" -> Message.TextMessage.serializer()
            else -> throw SerializationException("未知类型：$type")
        }
    }
}

@Serializable(with = MessageSerializer::class)
sealed class Message {
    abstract val type: String

    fun toJson(): String {
        return json.encodeToString(Message.serializer(), this)
    }

    companion object {
        private val json = Json {
            ignoreUnknownKeys = false
            encodeDefaults = true
        }

        fun fromStr(src: String): Message {
            return json.decodeFromString<Message>(src)
        }
    }

    @Serializable
    data class LedMessage(val value: Int, override val type: String = "led") : Message()

    @Serializable
    data class TextMessage(val text: String, override val type: String = "text") : Message()
}

在这个实现中，MessageSerializer 会根据 JSON 中的 type 字段动态选择合适的反序列化器，从而实现多态反序列化。

Rust 与 Kotlin 的互操作性

为了实现 Rust 与 Kotlin 之间的无缝通信，我们可以在 Rust 中将 Message 枚举序列化为 JSON，然后在 Kotlin 中反序列化，或者反向操作。

Rust 到 JSON

let led_message = Message::Led(LedMessage { value: 33 });
let json = led_message.to_json().unwrap();
println!("{}", json);

输出：

{"type":"led","value":33}

Kotlin 从 JSON

val json = """{"type":"led","value":33}"""
val message = Message.fromStr(json)
println(message)

输出：

LedMessage(value=33, type=led)

通过这种方式，Rust 和 Kotlin 可以共享相同的数据结构，确保数据的一致性和类型安全。

总结

通过利用 Rust 的 serde 和 Kotlin 的 kotlinx.serialization，我们可以实现优雅且高效的多态序列化。这种方式不仅确保了类型安全，还促进了不同语言之间的平滑数据交换。采用这些序列化技术，可以增强应用程序的互操作性，使其更加健壮和可维护。