使用 serde 通过数值作为类型标识符对 json 进行反序列化

我对 Rust 很陌生，并且有 OOP 背景。所以，也许我误解了一些 Rust 基础知识。

我想用 serde 解析固定的 json 结构。该结构代表不同的消息类型之一。每条消息都有一个数字type属性来区分它。各个消息类型的确切结构大多不同，但它们也可以相同。

{"type": 1, "sender_id": 4, "name": "sender", ...}
{"type": 2, "sender_id": 5, "measurement": 3.1415, ...}
{"type": 3, "sender_id": 6, "measurement": 13.37, ...}
...

首先，我定义了一个enum还可以区分消息类型struct对于没有存储类型的字段的每种类型的消息。

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
enum Message {
    T1(Type1),
    T2(Type2),
    T3(Type3),
    // ...
}

#[derive(Debug, Serialize, Deserialize)]
struct Type1 {
    sender_id: u32,
    name: String,
    // ...
}
#[derive(Debug, Serialize, Deserialize)]
struct Type2 {
    sender_id: u32,
    measurement: f64,
    // ...
}
#[derive(Debug, Serialize, Deserialize)]
struct Type3 {
    sender_id: u32,
    measurement: f64,
    // ...
}
// ...

当我尝试将字符串转换为Message对象，我收到错误。

let message = r#"{"type":1,"sender_id":123456789,"name":"sender"}"#;
let message: Message = serde_json::from_str(message)?; // error here
// Error: Custom { kind: InvalidData, error: Error("invalid type: integer `1`, expected variant identifier", line: 1, column: 9) }

因此，据我了解，serde 尝试找出当前消息的类型，但它需要一个字符串 为了那个原因。我也尝试写自己的deserialize()-功能。我试图获取数值 对应的type-key 并希望通过类型值创建特定对象。

我必须如何实施deserialize()提取消息的类型并创建特定的消息对象？是否可以在不写的情况下写这个deserialize()- 每个功能Type1/2/3/... struct?

impl<'de> Deserialize<'de> for Message {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                  where D: Deserializer<'de>,
{
    // which functions I have to call?
}

或者有更好的解决方案来实现我的反序列化吗？

我为这个问题准备了一个游乐场：

Serde 尚不支持整数标签（请参阅问题 #745 https://github.com/serde-rs/serde/issues/745).

如果您能够更改生成数据的内容，那么如果您能够更改type成一个字符串，即"1"代替1。然后你只需使用它就可以让它工作#[serde(rename)] https://serde.rs/field-attrs.html#rename.

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
enum Message {
    #[serde(rename = "1")]
    T1(Type1),
    #[serde(rename = "2")]
    T2(Type2),
    #[serde(rename = "3")]
    T3(Type3),
    // ...
}

如果这不是一个选项，那么您确实需要创建一个自定义解串器。就代码而言最短，很可能反序列化为serde_json::Value https://docs.serde.rs/serde_json/enum.Value.html，然后匹配type, and 反序列化 the serde_json::Value进入正确的Type{1,2,3}.

use serde_json::Value;

impl<'de> serde::Deserialize<'de> for Message {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(d)?;

        Ok(match value.get("type").and_then(Value::as_u64).unwrap() {
            1 => Message::T1(Type1::deserialize(value).unwrap()),
            2 => Message::T2(Type2::deserialize(value).unwrap()),
            3 => Message::T3(Type3::deserialize(value).unwrap()),
            type_ => panic!("unsupported type {:?}", type_),
        })
    }
}

您可能想要执行一些适当的操作错误处理 https://serde.rs/error-handling.html，而不是打开包裹并惊慌失措。

如果您还需要序列化，那么您同样需要一个自定义序列化器。为此，您可以创建一个新类型来序列化，因为您不能使用Message.

use serde::Serializer;

impl Serialize for Message {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        #[derive(Serialize)]
        #[serde(untagged)]
        enum Message_<'a> {
            T1(&'a Type1),
            T2(&'a Type2),
            T3(&'a Type3),
        }

        #[derive(Serialize)]
        struct TypedMessage<'a> {
            #[serde(rename = "type")]
            t: u64,
            #[serde(flatten)]
            msg: Message_<'a>,
        }

        let msg = match self {
            Message::T1(t) => TypedMessage { t: 1, msg: Message_::T1(t) },
            Message::T2(t) => TypedMessage { t: 2, msg: Message_::T2(t) },
            Message::T3(t) => TypedMessage { t: 3, msg: Message_::T3(t) },
        };
        msg.serialize(serializer)
    }
}

使用时#[serde(flatten)] https://serde.rs/field-attrs.html#flatten，然后它使用serde::private::ser::FlatMapSerializer https://github.com/serde-rs/serde/blob/8847800ce2cf404ae5f02485f030e380b246421e/serde/src/private/ser.rs#L1028，它在文档中是隐藏的。您可以使用以下方法来代替创建新类型SerializeMap https://docs.rs/serde/*/serde/ser/trait.SerializeMap.html and FlatMapSerializer.

但是，请注意，鉴于它没有记录，那么任何未来版本的 serdecould如果您正在使用，请破坏您的代码FlatMapSerializer直接地。

use serde::{private::ser::FlatMapSerializer, ser::SerializeMap, Serializer};

impl Serialize for Message {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_map(None)?;

        let type_ = &match self {
            Message::T1(_) => 1,
            Message::T2(_) => 2,
            Message::T3(_) => 3,
        };
        s.serialize_entry("type", &type_)?;

        match self {
            Message::T1(t) => t.serialize(FlatMapSerializer(&mut s))?,
            Message::T2(t) => t.serialize(FlatMapSerializer(&mut s))?,
            Message::T3(t) => t.serialize(FlatMapSerializer(&mut s))?,
        }

        s.end()
    }
}