When you need to serialize and deserialize data in Rust code, the serde library serves as a powerful and flexible tool. It supports multiple data formats and can easily convert Rust data structures into textual or binary representations of these formats.

Here are some common data format processing methods:

Examples：

Introduction to Serde

Serde is a framework for efficient and general-purpose serialization and deserialization of Rust data structures.

The Serde ecosystem consists of two parts: data structures that can serialize and deserialize themselves, and format modules that can handle serialization of other data. Serde acts as a bridge between the two, allowing any supported data structure to be serialized using any supported format.

Serde is built on Rust's powerful trait system. Data structures gain serialization capabilities by implementing Serde's Serialize and Deserialize traits (or by using Serde's derive attributes to automatically generate implementations at compile time).

Traits

Trait Purpose
Deserialize Data structure can be serialized
Deserializer How a data format serializes data
Serialize Data structure can be deserialized
Serializer How a data format deserializes data

Understanding Deserialize, Deserializer, Serialize, Serializer

We'll demonstrate Serde's core concepts using a simple Rust struct Person and JSON data format.

Defining the data structure (implementing Serialize and Deserialize):

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
}
  • Serialize: Indicates that Person can be serialized (e.g., converted to JSON).
  • Deserialize: Indicates that Person can be deserialized (e.g., parsed back from JSON).

Converting Person to a JSON string:

fn main() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };

    // Using `serde_json::Serializer` (JSON format serializer)
    let json_str = serde_json::to_string(&person).unwrap();
    println!("Serialized: {}", json_str); // Output: {"name":"Alice","age":30}
}
  • The variable person implements Serialize, so it can be serialized.
  • The serde_json::to_string function internally uses serde_json::Serializer, which is responsible for converting Rust structures to JSON strings.

Parsing a JSON string back into Person:

fn main() {
    let json_str = r#"{"name":"Bob","age":25}"#;

    // Using `serde_json::Deserializer` (JSON format deserializer)
    let person: Person = serde_json::from_str(json_str).unwrap();
    println!("Deserialized: {:?}", person); // Output: Person { name: "Bob", age: 25 }
}
  • Person implements Deserialize, so it can be deserialized.
  • The serde_json::from_str function internally uses serde_json::Deserializer, which is responsible for parsing JSON strings into Rust structures.