---

Rust 中自定义序列化逻辑

在 Rust 中，序列化与反序列化（通常称为“编码”和“解码”）是与数据交换相关的重要任务。Rust 的 serde 库是实现数据序列化和反序列化的最常用工具，它提供了一个强大且灵活的框架来自动化这项工作。然而，在一些特定的应用场景中，我们可能需要对默认的序列化行为进行定制，以满足业务逻辑或性能需求。本文将探讨如何在 Rust 中实现自定义序列化逻辑，展示如何根据需求对数据的序列化与反序列化过程进行精细化控制。

一、序列化与反序列化基础

serde 是 Rust 生态中最常用的序列化框架，支持 JSON、YAML、CBOR 等多种数据格式的序列化。默认情况下，serde 会根据结构体的字段和其类型自动生成序列化和反序列化代码。这使得大多数场景下的序列化过程非常简单，但当遇到特殊需求时，我们可能需要自定义序列化逻辑。

二、为什么需要自定义序列化

有时我们不希望序列化的数据完全符合结构体的默认格式。例如：

1. 字段重命名：我们可能希望序列化的 JSON 字段名称与结构体中的字段名称不同。

2. 数据转换：我们可能希望在序列化过程中对数据进行转换（如时间戳格式化、值的加密/解密等）。

3. 条件序列化：我们可能希望根据某些条件决定是否序列化某个字段。

4. 非默认值处理：有时我们希望在序列化时排除某些值，或者在反序列化时处理复杂的转换。

三、实现自定义序列化逻辑

为了自定义序列化逻辑，serde 提供了 Serialize 和 Deserialize trait。通过实现这两个 trait，我们可以控制对象在序列化和反序列化过程中的行为。

1. 自定义序列化实现

要自定义序列化，我们可以通过实现 Serialize trait 来控制对象的序列化过程。例如，如果我们希望对某个字段的值进行特殊处理，如将其转换为时间戳：

use serde::{Serialize, Serializer};
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Debug)]
struct Event {
    name: String,
    timestamp: SystemTime,
}

// 自定义序列化：将 `timestamp` 转换为 Unix 时间戳（秒）
impl Serialize for Event {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Event", 2)?;
        state.serialize_field("name", &self.name)?;
        let timestamp = self.timestamp.duration_since(UNIX_EPOCH).unwrap().as_secs();
        state.serialize_field("timestamp", &timestamp)?;
        state.end()
    }
}

fn main() {
    let event = Event {
        name: "Birthday".to_string(),
        timestamp: SystemTime::now(),
    };

    let serialized = serde_json::to_string(&event).unwrap();
    println!("{}", serialized);
}

在这个例子中，我们自定义了 Event 结构体的序列化逻辑，将 timestamp 字段转换为 Unix 时间戳。在序列化时，timestamp 将以秒数形式被表示，而不是 SystemTime 类型的默认表示。

2. 自定义反序列化实现

同样地，反序列化也可以通过实现 Deserialize trait 来定制。在下面的例子中，我们会将 Unix 时间戳反序列化回 SystemTime 类型：

use serde::{Deserialize, Deserializer};
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Debug)]
struct Event {
    name: String,
    timestamp: SystemTime,
}

// 自定义反序列化：将 Unix 时间戳转换为 `SystemTime`
impl<'de> Deserialize<'de> for Event {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        use serde::de::{Visitor, Error};

        struct EventVisitor;

        impl<'de> Visitor<'de> for EventVisitor {
            type Value = Event;

            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
            where
                M: serde::de::MapAccess<'de>,
            {
                let mut name = None;
                let mut timestamp = None;

                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "name" => {
                            name = Some(map.next_value()?);
                        }
                        "timestamp" => {
                            let ts: u64 = map.next_value()?;
                            timestamp = Some(UNIX_EPOCH + std::time::Duration::new(ts, 0));
                        }
                        _ => {}
                    }
                }

                let name = name.ok_or_else(|| M::Error::missing_field("name"))?;
                let timestamp = timestamp.ok_or_else(|| M::Error::missing_field("timestamp"))?;
                Ok(Event { name, timestamp })
            }
        }

        deserializer.deserialize_map(EventVisitor)
    }
}

fn main() {
    let data = r#"{"name": "Birthday", "timestamp": 1634601600}"#;
    let event: Event = serde_json::from_str(data).unwrap();
    println!("{:?}", event);
}

在这个例子中，我们通过 EventVisitor 实现了自定义的反序列化逻辑，将 Unix 时间戳转换为 SystemTime。

3. 处理条件序列化

有时我们需要根据某些条件来决定是否序列化某个字段。例如，只有在某个字段的值大于 0 时，才序列化它。可以使用 skip_serializing_if 属性来实现：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Product {
    name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    price: Option<f64>,
}

fn main() {
    let product = Product {
        name: "Laptop".to_string(),
        price: None,
    };

    let serialized = serde_json::to_string(&product).unwrap();
    println!("{}", serialized);  // price 字段不会被序列化
}

在此代码中，price 字段如果为 None，则不会被序列化。

四、总结

Rust 中的 serde 库通过强大的序列化与反序列化功能，允许开发者自定义数据的编码与解码过程。通过实现 Serialize 和 Deserialize trait，我们可以灵活地控制数据如何转换、存储和传输。自定义序列化逻辑不仅可以处理常见的转换需求，还能满足一些特定的业务场景，比如字段转换、条件序列化等。

通过理解并应用自定义序列化，我们能够在处理复杂数据格式和进行高效数据传输时，提高系统的灵活性与性能。