Serde：让Rust数据序列化变得超简单！

原创于 2025-10-02 11:33:44 发布 · 960 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#rust #开发语言 #后端 #其他

写在前面

刚接触Rust的时候，最让我头疼的就是数据序列化这件事。想把一个结构体转成JSON？想从配置文件读取数据？这些在其他语言里可能几行代码就搞定的事情，在Rust里总是显得特别复杂。

直到我遇到了Serde！！！

这个库简直就是Rust世界里的魔法棒。无论你要处理JSON、YAML、TOML，还是各种二进制格式，Serde都能轻松搞定。今天就来聊聊这个让无数Rust开发者爱不释手的序列化框架。

什么是Serde？

Serde的全名是"Serialization and Deserialization"（序列化和反序列化）。简单来说，它就是帮你把Rust的数据结构转换成其他格式，或者反过来的工具。

想象一下这样的场景：

你写了个配置文件，是TOML格式的
你需要把用户数据保存成JSON
你要和其他服务通过API交换数据

没有Serde的话，你得手动写一大堆转换代码。有了Serde，这些事情变得超级简单！

快速上手（5分钟就能跑起来）

添加依赖

首先在你的Cargo.toml里加上这些：

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"  # 如果要处理JSON

这里有个小细节要注意：features = ["derive"]这个特性超级重要！它让我们可以用派生宏，省去大量手写代码的工作。

第一个例子

来看最简单的例子：

use serde::{Deserialize, Serialize};

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

fn main() {
    let user = User {
        name: "张三".to_string(),
        age: 25,
        email: "zhangsan@example.com".to_string(),
    };
    
    // 序列化成JSON
    let json = serde_json::to_string(&user).unwrap();
    println!("JSON: {}", json);
    
    // 从JSON反序列化
    let user_from_json: User = serde_json::from_str(&json).unwrap();
    println!("从JSON解析: {}", user_from_json.name);
}

就这么简单！两个派生宏Serialize和Deserialize，你的结构体就具备了序列化能力。

处理不同的数据格式

JSON处理

JSON是最常用的格式了。Serde的JSON支持非常完善：

use serde_json::{Value, json};

// 直接创建JSON值
let data = json!({
    "name": "李四",
    "hobbies": ["编程", "游戏", "读书"],
    "is_student": true
});

// 美化输出
let pretty = serde_json::to_string_pretty(&data).unwrap();
println!("{}", pretty);

TOML配置文件

处理配置文件，TOML格式特别受欢迎：

// 先添加依赖：toml = "0.8"
use serde::{Deserialize, Serialize};
use toml;

#[derive(Serialize, Deserialize)]
struct Config {
    database_url: String,
    port: u16,
    debug: bool,
}

fn main() {
    let config = Config {
        database_url: "postgresql://localhost/mydb".to_string(),
        port: 8080,
        debug: true,
    };
    
    let toml_string = toml::to_string(&config).unwrap();
    println!("TOML配置:\n{}", toml_string);
}

输出会是这样的：

database_url = "postgresql://localhost/mydb"
port = 8080
debug = true

高级特性（这里才是精华！）

字段重命名

有时候你的Rust字段名和JSON字段名不一样，怎么办？

#[derive(Serialize, Deserialize)]
struct ApiResponse {
    #[serde(rename = "user_id")]
    id: u64,
    
    #[serde(rename = "user_name")]
    name: String,
    
    #[serde(rename = "created_at")]
    created_time: String,
}

这样，Rust里的id字段在JSON里就变成了user_id。

可选字段处理

处理可能不存在的字段：

#[derive(Serialize, Deserialize)]
struct Profile {
    name: String,
    
    #[serde(skip_serializing_if = "Option::is_none")]
    avatar: Option<String>,
    
    #[serde(default)]
    is_verified: bool,
}

skip_serializing_if表示如果字段是None，序列化时就不包含这个字段。default表示反序列化时如果没有这个字段，就用默认值。

自定义序列化

有时候需要特殊的序列化逻辑：

use serde::{Serializer, Deserializer};
use chrono::{DateTime, Utc};

fn serialize_timestamp<S>(date: &DateTime<Utc>, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    let timestamp = date.timestamp();
    serializer.serialize_i64(timestamp)
}

#[derive(Serialize)]
struct Event {
    name: String,
    
    #[serde(serialize_with = "serialize_timestamp")]
    occurred_at: DateTime<Utc>,
}

实际应用场景

Web API开发

在Web开发中，Serde简直是神器：

#[derive(Serialize, Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
    password: String,
}

#[derive(Serialize)]
struct CreateUserResponse {
    id: u64,
    name: String,
    #[serde(skip)]  // 永远不序列化密码！
    password: String,
}

配置文件管理

#[derive(Deserialize)]
struct DatabaseConfig {
    host: String,
    port: u16,
    username: String,
    password: String,
    #[serde(default = "default_max_connections")]
    max_connections: u32,
}

fn default_max_connections() -> u32 {
    10
}

// 从文件加载配置
fn load_config() -> Result<DatabaseConfig, Box<dyn std::error::Error>> {
    let config_str = std::fs::read_to_string("config.toml")?;
    let config: DatabaseConfig = toml::from_str(&config_str)?;
    Ok(config)
}

性能考虑

Serde的性能表现相当不错！它在编译时就生成了很多优化代码，运行时开销很小。

不过有几个小贴士：

对于大数据量，考虑使用流式处理
JSON处理时，serde_json::from_str比serde_json::from_slice稍快一点
如果你只需要序列化或反序列化其中一个，只派生需要的trait

错误处理

实际项目中，错误处理不能马虎：

use serde_json::Error as JsonError;

fn parse_user_data(json_str: &str) -> Result<User, JsonError> {
    match serde_json::from_str::<User>(json_str) {
        Ok(user) => Ok(user),
        Err(e) => {
            eprintln!("解析用户数据失败: {}", e);
            Err(e)
        }
    }
}

一些实用技巧

处理嵌套结构

#[derive(Serialize, Deserialize)]
struct Company {
    name: String,
    employees: Vec<User>,
    address: Address,
}

#[derive(Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
    country: String,
}

嵌套结构也能无缝处理，只要每个结构体都派生了对应的trait。

处理枚举

#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
enum Message {
    Text { content: String },
    Image { url: String, alt: String },
    Video { url: String, duration: u32 },
}