Rust语言从入门到精通系列 - Serde序列化/反序列化模块入门指北

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

基础用法#

安装#

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

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

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

序列化#

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

1
use serde::{Serialize, Deserialize};
2

3
#[derive(Serialize)]
4
struct Animal {
5
    name: String,
6
    age: u32,
7
}

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

1
use serde_json;
2

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

反序列化#

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

1
use serde::{Serialize, Deserialize};
2

3
#[derive(Deserialize)]
4
struct Animal {
5
    name: String,
6
    age: u32,
7
}

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

1
use serde_json;
2

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

进阶用法#

自定义序列化和反序列化#

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

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

3
#[derive(Serialize, Deserialize)]
4
struct Animal {
5
    #[serde(serialize_with = "serialize_name", deserialize_with = "deserialize_name")]
6
    name: String,
7
    age: u32,
8
}
9

10
fn serialize_name<S>(name: &String, serializer: S) -> Result<S::Ok, S::Error>
11
where
12
    S: Serializer,
13
{
14
    serializer.serialize_str(&name.to_uppercase())
15
}
16

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

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

序列化和反序列化枚举#

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

1
use serde::{Serialize, Deserialize};
2

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

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

1
use serde_json;
2

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

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

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

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

1
use serde::{Serialize, Deserialize};
2

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

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

1
use serde_json;
2

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

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

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

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

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

1
use serde::{Serialize, Deserialize};
2

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

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

1
use serde_json;
2

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

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

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

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

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

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

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

1
use serde_json;
2

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

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

总结#

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

音乐

音乐