Serde反序列化含可选元素的异构元组数组问题咨询

核心思路 #

不用按顺序直接强转元素类型，而是逐个读取并判断类型：先读取前两个固定元素（数字和SomeStruct），再对第三个元素做类型识别——如果是JSON对象就反序列化为OtherStruct，再读取后续的两个字符串；如果是字符串，就将其作为第一个字符串，同时标记可选结构体不存在。

实现代码 #

use serde::{de::SeqAccess, Deserialize, Deserializer};
use serde_json::Value;

#[derive(Debug, Deserialize)]
struct SomeStruct {
    #[serde(rename = "some struct")]
    some_struct: String,
}

#[derive(Debug, Deserialize)]
struct OtherStruct {
    #[serde(rename = "optional struct")]
    optional_struct: String,
}

#[derive(Debug)]
struct ResultData {
    number: usize,
    some_struct: SomeStruct,
    maybe_struct: Option<OtherStruct>,
    string1: String,
    string2: String,
}

impl<'de> Deserialize<'de> for ResultData {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct ResultDataVisitor;

        impl<'de> serde::de::Visitor<'de> for ResultDataVisitor {
            type Value = ResultData;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("包含4或5个元素的JSON数组")
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: SeqAccess<'de>,
            {
                // 读取第一个固定元素：数字
                let number: usize = seq.next_element()?.ok_or_else(|| {
                    serde::de::Error::invalid_length(0, &"至少需要4个元素")
                })?;

                // 读取第二个固定元素：SomeStruct
                let some_struct: SomeStruct = seq.next_element()?.ok_or_else(|| {
                    serde::de::Error::invalid_length(1, &"至少需要4个元素")
                })?;

                // 处理第三个元素，判断是可选结构体还是第一个字符串
                let (maybe_struct, string1) = match seq.next_element::<Value>()? {
                    Some(Value::Object(obj)) => {
                        // 反序列化为OtherStruct，再读取String1
                        let opt_struct: OtherStruct = serde::Deserialize::deserialize(Value::Object(obj))?;
                        let s1: String = seq.next_element()?.ok_or_else(|| {
                            serde::de::Error::invalid_length(3, &"存在可选结构体时需要5个元素")
                        })?;
                        (Some(opt_struct), s1)
                    }
                    Some(Value::String(s)) => {
                        // 无可选结构体，当前字符串就是String1
                        (None, s)
                    }
                    Some(other) => {
                        return Err(serde::de::Error::invalid_type(
                            serde::de::Unexpected::from(&other),
                            &"对象或字符串",
                        ));
                    }
                    None => {
                        return Err(serde::de::Error::invalid_length(
                            2,
                            &"至少需要4个元素",
                        ));
                    }
                };

                // 读取最后一个固定元素：String2
                let string2: String = seq.next_element()?.ok_or_else(|| {
                    let expected_len = if maybe_struct.is_some() { 5 } else { 4 };
                    serde::de::Error::invalid_length(
                        expected_len - 1,
                        &format!("总共需要{}个元素", expected_len),
                    )
                })?;

                // 检查是否有多余元素
                if seq.next_element::<Value>()?.is_some() {
                    let actual_len = if maybe_struct.is_some() { 6 } else { 5 };
                    return Err(serde::de::Error::invalid_length(
                        actual_len,
                        &"总共只能有4或5个元素",
                    ));
                }

                Ok(ResultData {
                    number,
                    some_struct,
                    maybe_struct,
                    string1,
                    string2,
                })
            }
        }

        deserializer.deserialize_seq(ResultDataVisitor)
    }
}

// 测试用例
fn main() -> Result<(), serde_json::Error> {
    // 含可选结构体的JSON
    let json_with_opt = r#"[ 123, {"some struct": "is always here"}, {"optional struct": "is not always here"}, "String1", "String2" ]"#;
    let data_with_opt: ResultData = serde_json::from_str(json_with_opt)?;
    println!("含可选结构体: {:?}", data_with_opt);

    // 不含可选结构体的JSON
    let json_without_opt = r#"[ 456, {"some struct": "still here"}, "StringA", "StringB" ]"#;
    let data_without_opt: ResultData = serde_json::from_str(json_without_opt)?;
    println!("不含可选结构体: {:?}", data_without_opt);

    Ok(())
}

关键细节 #

• 使用serde_json::Value作为中间类型，先获取元素的原始类型，再决定反序列化方式，避免直接强转失败导致的序列指针偏移
• 加入了完整的长度校验，包括元素不足、多余元素的错误提示，保证输入格式合规
• 通过Visitor自定义序列访问逻辑，完全掌控每个元素的读取和判断流程

内容的提问来源于stack exchange，提问作者arrtchiu