Rust自定义反序列化实现

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

#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
}

struct PersonVisitor;

impl<'de> Visitor<'de> for PersonVisitor {
    type Value = Person;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a JSON object with name and age")
    }

    fn visit_map<V>(self, mut map: V) -> Result<Person, V::Error>
    where
        V: MapAccess<'de>,
    {
        let mut name = None;
        let mut age = None;

        while let Some(key) = map.next_key()? {
            match key {
                "name" => {
                    if name.is_some() {
                        return Err(de::Error::duplicate_field("name"));
                    }
                    name = Some(map.next_value()?);
                }
                "age" => {
                    if age.is_some() {
                        return Err(de::Error::duplicate_field("age"));
                    }
                    age = Some(map.next_value()?);
                }
                _ => {
                    return Err(de::Error::unknown_field(&key, &["name", "age"]));
                }
            }
        }

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

        Ok(Person { name, age })
    }
}

impl<'de> Deserialize<'de> for Person {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_struct("Person", &["name", "age"], PersonVisitor)
    }
}

fn main() {
    let json = r#"{"name": "Alice", "age": 30}"#;
    let person: Person = serde_json::from_str(json).unwrap();
    println!("{:?}", person);
}