第十一序列化、反序列化、持久化

最新推荐文章于 2026-04-12 10:15:18 发布

原创最新推荐文章于 2026-04-12 10:15:18 发布 · 599 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Rust七十二变

本文介绍了序列化和反序列化在Rust编程中的使用，特别是Serde库的应用，涵盖了如何将对象状态转换为各种数据格式，以及在网络传输和持久化中的重要性。同时，详细展示了如何使用Serde库处理`Duration`结构的序列化和反序列化过程。

序列化、反序列化

序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

序列化（编码）是将对象序列化为二进制形式（字节数组），主要用于网络传输、数据持久化等；而反序列化（解码）则是将从网络、磁盘等读取的字节数组还原成原始对象，主要用于网络传输对象的解码，以便完成远程调用。

常见的序列化数据格式有：JSON ,XML,BSON,YAML,TOML

Rust中的序列化和反序列化

Serde 是Rust中序列化和反序列化常用的库，支持多种数据格式。

use serde::Serialize;


#[derive(Serialize)]

#[serde(rename_all = "camelCase")]

struct Person {

    first_name: String,

    last_name: String,

}


fn main() {

    let person = Person {

        first_name: "Graydon".to_string(),

        last_name: "Hoare".to_string(),

    };


    let json = serde_json::to_string_pretty(&person).unwrap();


    // Prints:

    //

    //    {

    //      "firstName": "Graydon",

    //      "lastName": "Hoare"

    //    }

    println!("{}", json);

}

use std::fmt;

use serde::Serialize;

use serde::de::{self, Deserialize, Deserializer, Visitor, SeqAccess, MapAccess};


#[allow(dead_code)]

#[derive(Serialize)]

struct Duration {

    secs: u64,

    nanos: u32,

}


impl Duration {

    fn new(secs: u64, nanos: u32) -> Self {

        Duration{

            secs,

            nanos

        }

    }

}


impl<'de> Deserialize<'de> for Duration {

    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

    where

        D: Deserializer<'de>,

    {

        enum Field { Secs, Nanos }


        // This part could also be generated independently by:

        //

        //    #[derive(Deserialize)]

        //    #[serde(field_identifier, rename_all = "lowercase")]

        //    enum Field { Secs, Nanos }

        impl<'de> Deserialize<'de> for Field {

            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>

            where

                D: Deserializer<'de>,

            {

                struct FieldVisitor;


                impl<'de> Visitor<'de> for FieldVisitor {

                    type Value = Field;


                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

                        formatter.write_str("`secs` or `nanos`")

                    }


                    fn visit_str<E>(self, value: &str) -> Result<Field, E>

                    where

                        E: de::Error,

                    {

                        match value {

                            "secs" => Ok(Field::Secs),

                            "nanos" => Ok(Field::Nanos),

                            _ => Err(de::Error::unknown_field(value, FIELDS)),

                        }

                    }

                }


                deserializer.deserialize_identifier(FieldVisitor)

            }

        }


        struct DurationVisitor;


        impl<'de> Visitor<'de> for DurationVisitor {

            type Value = Duration;


            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

                formatter.write_str("struct Duration")

            }


            fn visit_seq<V>(self, mut seq: V) -> Result<Duration, V::Error>

            where

                V: SeqAccess<'de>,

            {

                let secs = seq.next_element()?

                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;

                let nanos = seq.next_element()?

                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;

                Ok(Duration::new(secs, nanos))

            }


            fn visit_map<V>(self, mut map: V) -> Result<Duration, V::Error>

            where

                V: MapAccess<'de>,

            {

                let mut secs = None;

                let mut nanos = None;

                while let Some(key) = map.next_key()? {

                    match key {

                        Field::Secs => {

                            if secs.is_some() {

                                return Err(de::Error::duplicate_field("secs"));

                            }

                            secs = Some(map.next_value()?);

                        }

                        Field::Nanos => {

                            if nanos.is_some() {

                                return Err(de::Error::duplicate_field("nanos"));

                            }

                            nanos = Some(map.next_value()?);

                        }

                    }

                }

                let secs = secs.ok_or_else(|| de::Error::missing_field("secs"))?;

                let nanos = nanos.ok_or_else(|| de::Error::missing_field("nanos"))?;

                Ok(Duration::new(secs, nanos))

            }

        }


        const FIELDS: &'static [&'static str] = &["secs", "nanos"];

        deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)

    }

}


fn main(){

    let duration = Duration::new(10u64,140_000_000u32);

    let json = serde_json::to_string_pretty(&duration).unwrap();

    println!("{}",json);

   

    if let Ok(duration2) = serde_json::from_str::<Duration>(&json){

        println!("secs:{}, nanos:{}",duration2.secs, duration2.nanos);

    }

   

}