Rust第三方库之Serde：序列化/反序列化库分析

serde库

Serde 是一个序列化和反序列化的库, 你会发现该库是各类应用中都会依赖用到的库，是一个非常基础的库, 值得我们去深入学习.
Serde自身并未提供具体的序列化与反序列化实现，需要结合社区提供的其他模块，实现对具体数据结构的操作。
大部分语言一般是通过反射实现序列化操作，性能开销普遍较大。而serde是基于rust的trait系统来实现序列化&反序列化，每种数据结构通过实现serde的Serialize和Deserialize接口来实现序列化功能，并且rust编译器可以在很多场景下对序列化进行高度优化，因此这种实现方案的性能特别高。

示例应用

1、准备工作

[dependencies]
serde = { version = "1.0", features = ["derive"] } # 引用serde并开启derive features
serde_json = "1.0" # 用于serde<-->json

2、示例代码

// 使用derive来进行序列化
#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn serde_attr_demo1() {
    let  p = Point{x:1, y:2};

    // 序列化：struct -> json
    let serialized = serde_json::to_string(&p).unwrap();
    println!("serialized = {}", serialized);

    // 反序列化： json -> struct
    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

fn serde_attr_demo2() {
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(deny_unknown_fields)]  // 确保当反序列化的字段不存在struct中 直接异常
    struct S {
        #[serde(default)]
        f: i32,
        ff: i32,
    }

    let fv = 2i32;
    let s = S{
        f: fv,
        ff: 200i32,
    };
    let serialize = serde_json::to_string(&s).unwrap();
    println!("serialize = {}", serialize);

    let ss = r#"{"f":2,"ff":222}"#;
    let deserialize: S = serde_json::from_str(ss).unwrap();
    println!("deserialize: {:?}", deserialize);

}

fn serde_attr_demo3() {
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(rename="e")]
    enum E {
        #[serde(rename="a")]
        A(String)
    }

    let e = E::A("hello".to_string());
    let serialize = serde_json::to_string(&e).unwrap();
    println!("serialize={:?}", serialize);

    let ss = r#"{"a":"world"}"#;
    let deserialize: E = serde_json::from_str(ss).unwrap();
    println!("deserialze={:?}", deserialize);
}

// 自定义实现序列化trait
fn serde_define_serialize_demo() {
    use serde::ser::{Serialize, Serializer, SerializeStruct};
    struct SS {
        f: i32,
    }

    impl Serialize for SS {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
            // 1. serialize struct
            // 2. serialize field
            // 3. return
            let mut state = serializer.serialize_struct("ss",  // name
                                                        1)?; // len: the number of fields
            state.serialize_field("f", &self.f)?;
            state.end()
        }
    }

    let ss = SS {
        f: 222i32,
    };
    let serialize = serde_json::to_string(&ss).unwrap();
    println!("serialize= {:?}", serialize);
}

fn serde_define_enum_serialize_demo() {
    enum E {
        Color {r: u8, g:u8, b:u8,},
        Point2D(f64, f64),
        Inches(u64),
        Instance,
    }

    impl Serialize for E {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
            match *self {
                E::Color { ref r, ref g, ref b } => {
                    let mut state = serializer.serialize_struct_variant("E",0,"Color", 3)?;
                    state.serialize_field("r",r)?;
                    state.serialize_field("g", g)?;
                    state.serialize_field("b", b)?;
                    state.end()
                }
                E::Point2D(ref __f0, ref __f1) => {
                    let mut state = serializer.serialize_tuple_variant("E", 1, "Point2D", 2)?;
                    state.serialize_field(__f0)?;
                    state.serialize_field(__f1)?;
                    state.end()
                }
                E::Inches(ref __f0) => {
                   serializer.serialize_newtype_variant("E",2, "Inches", __f0)
                }
                E::Instance => {
                    serializer.serialize_unit_variant("E", 3, "Instance")
                }
                _ => {
                    todo!()
                }
            }
        }
    }

    let e = E::Color {
        r: 120u8,
        g: 120u8,
        b: 120u8,
    };
    let se = serde_json::to_string(&e).unwrap();
    println!("serialize= {:?}", se);

    let e2d = E::Point2D(122f64, 122f64,);
    let se2d = serde_json::to_string(&e2d).unwrap();
    println!("serialize 2d= {:?}", se2d);

    let eInches = E::Inches(122u64,);
    let seInches = serde_json::to_string(&eInches).unwrap();
    println!("serialize seInches= {:?}", seInches);

    let eInstance = E::Instance;
    let seInstance = serde_json::to_string(&eInstance).unwrap();
    println!("serialize eInstance= {:?}", seInstance);
}

引用

serde概述
serde实现自定义的trait serialize
serde支持的数据模型