如何使用Serde进行序列化和反序列化

Serde 是一个用于序列化和反序列化 Rust 数据结构的库。它支持 JSON、BSON、YAML 等多种格式，并且可以自定义序列化和反序列化方式。Serde 的特点是代码简洁、易于使用、性能高效。它是 Rust 生态中最受欢迎的序列化库之一。

基础用法

安装

在 Rust 项目中使用 Serde，需要在Cargo.toml文件中添加如下依赖：

[dependencies]
serde = { version = "1.0", features = ["derive"] }

其中features = ["derive"]表示使用 Serde 的派生宏，可以自动生成序列化和反序列化代码。

序列化

使用 Serde 进行序列化，需要先将数据结构实现serde::Serialize trait。例如，我们定义一个Animal结构体，包含名称和年龄两个字段：

#[derive(Serialize)]
struct Animal {
    name: String,
    age: u32,
}

然后，我们可以使用serde_json库将Animal结构体序列化为 JSON 字符串：

use serde_json;

let animal = Animal {
    name: "Tom".to_owned(),
    age: 3,
};
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"name":"Tom","age":3}

反序列化

使用 Serde 进行反序列化，需要先将数据结构实现serde::Deserialize trait。例如，我们定义一个Animal结构体，包含名称和年龄两个字段：

#[derive(Deserialize)]
struct Animal {
    name: String,
    age: u32,
}

然后，我们可以使用serde_json库将 JSON 字符串反序列化为Animal结构体：

use serde_json;

let json = r#"{"name":"Tom","age":3}"#;
let animal: Animal = serde_json::from_str(json).unwrap();
println!("{:?}", animal); // Animal { name: "Tom", age: 3 }

进阶用法

自定义序列化和反序列化

如果默认的序列化和反序列化方式无法满足需求，可以自定义序列化和反序列化方式。例如，我们定义一个Animal结构体，包含名称和年龄两个字段，但是希望在序列化时，将名称转换为大写字母，反序列化时，将名称转换为小写字母：

use serde::{Serialize, Deserialize, Serializer, Deserializer};

#[derive(Serialize, Deserialize)]
struct Animal {
    #[serde(serialize_with = "serialize_name", deserialize_with = "deserialize_name")]
    name: String,
    age: u32,
}

fn serialize_name< S >(name: &String, serializer: S) - > Result< S::Ok, S::Error >
where
    S: Serializer,
{
    serializer.serialize_str(&name.to_uppercase())
}

fn deserialize_name< 'de, D >(deserializer: D) - > Result< String, D::Error >
where
    D: Deserializer< 'de >,
{
    let name = String::deserialize(deserializer)?;
    Ok(name.to_lowercase())
}

在Animal结构体中，我们使用#[serde(serialize_with = "serialize_name", deserialize_with = "deserialize_name")]指定了自定义的序列化和反序列化方法。serialize_name函数将名称转换为大写字母，deserialize_name函数将名称转换为小写字母。

序列化和反序列化枚举

Serde 支持序列化和反序列化枚举类型。例如，我们定义一个Animal枚举，包含狗和猫两种类型：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Animal {
    Dog { name: String, age: u32 },
    Cat { name: String, age: u32 },
}

在序列化和反序列化枚举类型时，需要使用#[serde(tag = "type")]指定枚举类型的标签，例如：

use serde_json;

let dog = Animal::Dog { name: "Tom".to_owned(), age: 3 };
let json = serde_json::to_string(&dog).unwrap();
println!("{}", json); // {"type":"Dog","name":"Tom","age":3}

let json = r#"{"type":"Dog","name":"Tom","age":3}"#;
let dog: Animal = serde_json::from_str(json).unwrap();
println!("{:?}", dog); // Dog { name: "Tom", age: 3 }

序列化和反序列化结构体中的 Option

Serde 支持序列化和反序列化结构体中的Option类型。例如，我们定义一个Animal结构体，包含名称和年龄两个字段，其中名称可以为空：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Animal {
    name: Option< String >,
    age: u32,
}

在序列化和反序列化结构体中的Option类型时，需要使用#[serde(skip_serializing_if = "Option::is_none")]指定当Option值为None时，不进行序列化。例如：

use serde_json;

let animal = Animal { name: Some("Tom".to_owned()), age: 3 };
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"name":"Tom","age":3}

let animal = Animal { name: None, age: 3 };
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"age":3}

let json = r#"{"age":3}"#;
let animal: Animal = serde_json::from_str(json).unwrap();
println!("{:?}", animal); // Animal { name: None, age: 3 }

序列化和反序列化结构体中的 Vec

Serde 支持序列化和反序列化结构体中的Vec类型。例如，我们定义一个Zoo结构体，包含多个Animal：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Zoo {
    animals: Vec< Animal >,
}

在序列化和反序列化结构体中的Vec类型时，Serde 会自动处理序列化和反序列化。例如：

use serde_json;

let zoo = Zoo { animals: vec![
    Animal { name: "Tom".to_owned(), age: 3 },
    Animal { name: "Jerry".to_owned(), age: 2 },
] };
let json = serde_json::to_string(&zoo).unwrap();
println!("{}", json); // {"animals":[{"name":"Tom","age":3},{"name":"Jerry","age":2}]}

let json = r#"{"animals":[{"name":"Tom","age":3},{"name":"Jerry","age":2}]}"#;
let zoo: Zoo = serde_json::from_str(json).unwrap();
println!("{:?}", zoo); // Zoo { animals: [Animal { name: "Tom", age: 3 }, Animal { name: "Jerry", age: 2 }] }

序列化和反序列化结构体中的 HashMap

Serde 支持序列化和反序列化结构体中的HashMap类型。例如，我们定义一个Zoo结构体，包含多个Animal，使用HashMap存储：

use std::collections::HashMap;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Zoo {
    animals: HashMap< String, Animal >,
}

在序列化和反序列化结构体中的HashMap类型时，Serde 会自动处理序列化和反序列化。例如：

use serde_json;

let mut animals = HashMap::new();
animals.insert("Tom".to_owned(), Animal { name: "Tom".to_owned(), age: 3 });
animals.insert("Jerry".to_owned(), Animal { name: "Jerry".to_owned(), age: 2 });
let zoo = Zoo { animals };
let json = serde_json::to_string(&zoo).unwrap();
println!("{}", json); // {"animals":{"Jerry":{"name":"Jerry","age":2},"Tom":{"name":"Tom","age":3}}}

let json = r#"{"animals":{"Jerry":{"name":"Jerry","age":2},"Tom":{"name":"Tom","age":3}}}"#;
let zoo: Zoo = serde_json::from_str(json).unwrap();
println!("{:?}", zoo); // Zoo { animals: {"Tom": Animal { name: "Tom", age: 3 }, "Jerry": Animal { name: "Jerry", age: 2 }} }

总结

本教程介绍了如何使用 Serde 进行序列化和反序列化，并且介绍了如何自定义序列化和反序列化逻辑。使用 Serde 可以轻松地将 Rust 数据结构转换为任何格式，并且可以通过自定义序列化和反序列化逻辑实现更高级的功能。