如何在反序列化枚举变体时复用已派生的Deserialize实现？

问题分析 #

核心需求是避免手动匹配MyError的所有变体，直接复用其已派生的Deserialize实现。当前的问题在于Visitor中错误地将value固定为String类型，且未利用MapAccess提供的原生反序列化能力。

修改后的代码实现 #

use serde::{Deserialize, Deserializer, Serialize, de::{Visitor, MapAccess, Error as DeError}};
use anyhow::Error;

enum GlobalError {
    MyErrorVariant(MyError), // 已派生ser/de
    AnyhowError(Error)       // 未实现ser/de
}

#[derive(Debug, Serialize, Deserialize)]
enum MyError {
    BadData,
    InvalidInput,
    NotFound,
    // 更多变体...
}

// 实现Serialize（保留原有逻辑）
impl Serialize for GlobalError {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            GlobalError::MyErrorVariant(err) => {
                serializer.serialize_newtype_variant("GlobalError", 0, "MyErrorVariant", err)
            }
            GlobalError::AnyhowError(err) => {
                serializer.serialize_newtype_variant("GlobalError", 1, "AnyhowError", &err.to_string())
            }
        }
    }
}

// 实现Deserialize，复用MyError的派生实现
impl<'de> Deserialize<'de> for GlobalError {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_map(GlobalErrorVisitor)
    }
}

struct GlobalErrorVisitor;

impl<'de> Visitor<'de> for GlobalErrorVisitor {
    type Value = GlobalError;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a map representing a GlobalError variant")
    }

    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    where
        A: MapAccess<'de>,
    {
        // 先读取key确定变体类型
        let (key, _) = map.next_entry::<String, serde::de::IgnoredAny>()?
            .ok_or_else(|| DeError::custom("empty error object"))?;

        let error = match key.as_str() {
            "AnyhowError" => {
                // 重置map到起始位置，完整读取字符串消息
                map.reset();
                let (_, msg) = map.next_entry::<String, String>()?
                    .ok_or_else(|| DeError::custom("missing AnyhowError message"))?;
                GlobalError::AnyhowError(anyhow::anyhow!(msg))
            }
            "MyErrorVariant" => {
                // 重置map，直接反序列化value为MyError，复用派生实现
                map.reset();
                let (_, my_err) = map.next_entry::<String, MyError>()?
                    .ok_or_else(|| DeError::custom("invalid MyErrorVariant data"))?;
                GlobalError::MyErrorVariant(my_err)
            }
            unknown => {
                return Err(DeError::unknown_variant(
                    unknown,
                    &["AnyhowError", "MyErrorVariant"],
                ));
            }
        };

        // 校验是否存在多余字段
        if map.next_entry::<String, serde::de::IgnoredAny>()?.is_some() {
            return Err(DeError::custom("unexpected extra fields in error object"));
        }

        Ok(error)
    }
}

关键改进点 #

1. 替换deserialize_any为deserialize_map：贴合序列化后的map格式，避免不必要的类型猜测。
2. 复用MyError的反序列化实现：
   • 先读取key确定变体，再通过map.reset()回到起始位置，直接反序列化value为MyError类型，无需手动匹配每个变体。
3. 增强错误处理：补充空map、多余字段、未知变体等场景的错误提示，提升代码鲁棒性。

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