如何使用Serde自定义Result类型的序列化与反序列化？

默认情况下，Serde对Result类型的序列化会生成{"Ok": ...}或{"Err": ...}格式的JSON，无法满足你需要的成功时输出result字段、失败时输出error字段的需求。要实现这种自定义格式，需要手动实现Serialize和Deserialize trait，而非依赖自动派生。

实现步骤与代码示例 #

1. 基础结构体定义

首先移除自动派生的Serialize和Deserialize，保留核心字段：

use serde::{Serialize, Deserialize, Serializer, Deserializer};
use serde::de::{MapAccess, Visitor};
use std::fmt;

struct ServerResponse<D, E> {
    result: Result<D, E>,
    version: String,
    // 可添加其他自定义字段
}

2. 实现自定义序列化逻辑

根据Result的状态，选择向JSON中写入result或error字段：

impl<D, E> Serialize for ServerResponse<D, E>
where
    D: Serialize,
    E: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // 初始化JSON映射，长度设为None让Serde自动处理
        let mut map = serializer.serialize_map(None)?;
        
        // 写入固定的version字段
        map.serialize_entry("version", &self.version)?;
        
        // 根据Result状态写入对应字段
        match &self.result {
            Ok(data) => map.serialize_entry("result", data)?,
            Err(err) => map.serialize_entry("error", err)?,
        }
        
        // 如果有其他字段，在此处添加序列化逻辑
        // map.serialize_entry("other_field", &self.other_field)?;
        
        map.end()
    }
}

3. 实现自定义反序列化逻辑

需要自定义Visitor来解析JSON，判断是result还是error字段，并处理必填字段校验：

impl<'de, D, E> Deserialize<'de> for ServerResponse<D, E>
where
    D: Deserialize<'de>,
    E: Deserialize<'de>,
{
    fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
    where
        De: Deserializer<'de>,
    {
        // 定义Visitor结构体，用于解析JSON映射
        struct ServerResponseVisitor<D, E>(std::marker::PhantomData<(D, E)>);
        
        impl<'de, D, E> Visitor<'de> for ServerResponseVisitor<D, E>
        where
            D: Deserialize<'de>,
            E: Deserialize<'de>,
        {
            type Value = ServerResponse<D, E>;
            
            // 反序列化失败时的提示信息
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("ServerResponse对象，需包含version字段，以及result或error字段之一")
            }
            
            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
            where
                M: MapAccess<'de>,
            {
                let mut version: Option<String> = None;
                let mut result: Option<Result<D, E>> = None;
                // 其他字段的Option定义，例如：
                // let mut other_field: Option<u32> = None;
                
                // 遍历JSON中的键值对
                while let Some((key, value)) = map.next_entry()? {
                    match key {
                        "version" => {
                            if version.is_some() {
                                return Err(serde::de::Error::duplicate_field("version"));
                            }
                            version = Some(value);
                        }
                        "result" => {
                            if result.is_some() {
                                return Err(serde::de::Error::duplicate_field("result/error"));
                            }
                            result = Some(Ok(value));
                        }
                        "error" => {
                            if result.is_some() {
                                return Err(serde::de::Error::duplicate_field("result/error"));
                            }
                            result = Some(Err(value));
                        }
                        // 处理其他自定义字段
                        // "other_field" => {
                        //     if other_field.is_some() {
                        //         return Err(serde::de::Error::duplicate_field("other_field"));
                        //     }
                        //     other_field = Some(value);
                        // }
                        _ => return Err(serde::de::Error::unknown_field(key, &["version", "result", "error"])),
                    }
                }
                
                // 校验必填字段是否存在
                let version = version.ok_or_else(|| serde::de::Error::missing_field("version"))?;
                let result = result.ok_or_else(|| serde::de::Error::missing_field("result或error"))?;
                
                Ok(ServerResponse {
                    result,
                    version,
                    // other_field: other_field.ok_or_else(|| serde::de::Error::missing_field("other_field"))?,
                })
            }
        }
        
        deserializer.deserialize_map(ServerResponseVisitor(std::marker::PhantomData))
    }
}

4. 测试示例

定义测试用的数据和错误结构体，验证序列化与反序列化效果：

#[derive(Debug, Serialize, Deserialize)]
struct MyData(String);

#[derive(Debug, Serialize, Deserialize)]
struct MyError {
    message: String,
    #[serde(rename = "error-code")]
    error_code: u32,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 序列化成功响应
    let success_resp = ServerResponse {
        result: Ok(MyData("my_result_data".to_string())),
        version: "1.0".to_string(),
    };
    let success_json = serde_json::to_string_pretty(&success_resp)?;
    println!("成功响应JSON:\n{}", success_json);
    
    // 序列化失败响应
    let error_resp = ServerResponse {
        result: Err(MyError {
            message: "The request failed".to_string(),
            error_code: 212,
        }),
        version: "1.0".to_string(),
    };
    let error_json = serde_json::to_string_pretty(&error_resp)?;
    println!("失败响应JSON:\n{}", error_json);
    
    // 反序列化测试
    let parsed_success: ServerResponse<MyData, MyError> = serde_json::from_str(&success_json)?;
    println!("反序列化成功响应: {:?}", parsed_success.result);
    
    let parsed_error: ServerResponse<MyData, MyError> = serde_json::from_str(&error_json)?;
    println!("反序列化失败响应: {:?}", parsed_error.result);
    
    Ok(())
}

注意事项 #

• 确保D和E类型都实现了Serialize和Deserialize trait，否则无法在自定义逻辑中完成序列化/反序列化。
• 反序列化时处理了重复字段（同时出现result和error）、缺失必填字段的场景，返回符合Serde规范的错误信息。
• 如需添加其他字段，只需在结构体中新增字段，并在序列化、反序列化逻辑中添加对应的处理代码即可。

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