Serializacija in deserializacija JSON z Rust

JSON (JavaScript Object Notation) se je pojavil kot priljubljena oblika izmenjave podatkov v programski opremi razvoj zaradi svoje preprostosti, berljivosti in široke podpore v različnih programih jezikov. JSON je lahka alternativa XML-ju za prenos podatkov med strežnikom in spletno aplikacijo ali med različnimi komponentami programskega sistema.

Eden od ključnih vidikov dela z JSON je proces serializacije in deserializacije, ki vam omogoča pretvorbo podatkov JSON v strukturirano obliko, s katero lahko preprosto upravljate v svojem programi. V večini primerov, če želite delati z JSON v drugih jezikih, boste morda morali serializirati in deserializirati podatke JSON v vgrajene podatkovne strukture jezika.

Začetek uporabe Serde

Serde (serializacija in deserializacija) je široko uporabljena knjižnica Rust, ki zagotavlja okvir za pretvorbo Podatkovne strukture Rust v formate za shranjevanje, prenos, skupno rabo in drugo.

Serde omogoča brezhibno pretvorbo med vrstami podatkov Rust in različnimi formati za izmenjavo podatkov, vključno z JSON, YAML, BSON, CBOR, MessagePack in drugimi.

Serdejev glavni poudarek je narediti postopek serializacije in deserializacije čim bolj preprost in učinkovit, hkrati pa ohraniti močne funkcije tipkanja in varnosti.

Dodajte te direktive v odvisnosti del vašega Cargo.toml datoteko za namestitev in uporabo Serde kot odvisnost od tretjih oseb s storitvijo Cargo.

[odvisnosti]
serde = { različica = "1.0.159", funkcije = ["izpeljati"] }
serde_json = "1.0.96"

Potrebovali boste oboje serde in serde_json zabojev za interakcijo z JSON. The serde zaboj zagotavlja osnovne funkcije in serde_json crate je posebna implementacija Serde za delo z JSON.

Evo, kako lahko uvozite serde_json zaboj in Serializiraj in Deserializiraj moduli iz serde zaboj:

uporaba serde::{Serialize, Deserialize};
uporaba serde_json;

Na splošno je Serde močno orodje, ki ga boste potrebovali v svojem razvojnem arzenalu, če delate z JSON v Rustu.

Serializacija podatkov s Serde

Postopek serializacije JSON vključuje pretvorbo vrste Rust (po meri ali vgrajene) v JSON za druge operacije. Serde ponuja nabor atributov, ki jih lahko uporabite z Rust struct, da omogočite natančen nadzor nad postopkom serializacije, vključno z #[izpelji (serializiraj)] atribut, ki vam omogoča ustvarjanje serializacijske kode za vaše podatkovne strukture in pretvorbo strukture Rust v JSON.

Razmislite o tej strukturi, ki predstavlja biološke podatke osebe; tukaj je opisano, kako lahko uvozite in uporabite Serializiraj atribut na strukturi:

uporaba serde::{Serialize, Deserialize};
uporaba serde_json;
#[izpelji (serializiraj)]
structOseba {
 ime: Vrvica,
 starost: u32,
}

Z označevanjem Oseba struct z [#derive (Serialize)], sporočate Serdeju, naj ustvari potrebno serializacijsko kodo za Oseba samodejno strukturirati.

Evo, kako lahko serializirate primerek Oseba struct v JSON:

uporaba serde::{Serialize};
uporaba serde_json;
fnglavni() {
// deklaracija primerka strukture Person s polji za ime in starost
pustiti oseba = oseba {
 ime: "Chukwuemeriwo".to_string(),
 starost: 28,
 };
// serializira strukturo person v JSON z uporabo knjižnice serde_json
pustiti json = serde_json:: to_string(&oseba).expect("Serializacija ni uspela");
// natisne serializirani niz JSON
println!("Serializiran JSON: {}", json);
}

V glavni funkcija, serde_json zaboj serializira oseba predmet. The na_niz funkcija se sklicuje na oseba in vrne niz JSON, ki predstavlja serializirane podatke.

Končno, glavni funkcija natisne serializirani JSON na konzolo.

The serde in serde_json so vsestranski, lahko nize tudi serializirate s serde.

uporaba serde::{Serialize, Deserialize};
uporaba serde_json;
#[izpelji (serializiraj)]
structKoordinate {
 x: f32,
 y: f32,
}
fnglavni() {
pustiti točke = vec![ 
 Koordinate { x: 1.0, y: 2.0 },
 Koordinate { x: 3.5, y: 4.5 },
 ];
pustiti json = serde_json:: to_string(&points).expect("Serializacija ni uspela"); 
println!("Serializiran JSON: {}", json); // Natisnite serializirani niz JSON
}

The točke spremenljivka je vektor Koordinate strukture, ki predstavljajo točke na ravnini. Uporaba Serializiraj pripisati Koordinate struct vam omogoča serializacijo vektorja v JSON brez truda.

Poleg tega lahko enume serializirate v JSON z serde tako kot serializirate strukture in vektorje.

uporaba serde::{Serialize, Deserialize};
uporaba serde_json;
#[izpelji (serializiraj, deserializiraj)]
enumžival {
 pes(Vrvica),
 Mačka(u32),
 ptica,
}
fnglavni() {
pustiti pes = žival:: pes("Rusty".to_string());
pustiti json = serde_json:: to_string(&dog).expect("Serializacija ni uspela");
println!("Serializiran JSON: {}", json);
}

Odvisno od različice se postopek serializacije ustrezno prilagodi (v tem primeru Žival:: Pes različica vključuje a Vrvica polje, ki ga bo Serde serializiral kot niz JSON).

Deserializacija podatkov s Serde

Deserializacija JSON je postopek pretvorbe podatkov JSON v izvorne tipe podatkov programskega jezika. Serde ponuja celovit okvir za deserializacijo JSON, ki deluje na večini vgrajenih tipov podatkov.

Podobno kot pri serializaciji, Serde ponuja atribute, ki jih lahko uporabite za označevanje struktur Rust za postopek deserializacije. Dva pogosto uporabljena atributa za serializacijo sta #[izpelji (deserializiraj)] in #[serde (rename = "json_field_name")] lastnosti.

The #[izpelji (deserializiraj)] samodejno izpelje izvedbo deserializacije za vaš Vrste struktur rje, medtem ko je #[serde (rename = "json_field_name")] omogoča preslikavo polj struct v ustrezna imena polj JSON.

Tukaj je opisano, kako lahko s Serde deserializirate podatke JSON v vrsto strukture po meri:

uporaba serde:: deserializiraj;
uporaba serde_json;
// definira strukturo za osebo z lastnostjo Deserialize iz Serde
#[izpelji (deserializiraj)]
structOseba {
#[serde (preimenuj = "ime")]// preimenuje polje v "name" 
 polno ime: Vrvica, 
 starost: u32,
}
fnglavni() {
pustiti json_data = r#"
 {
"ime": "John Doe",
"starost": 30
 }
"#;
// deserializira podatke JSON v strukturo osebe 
pustiti oseba: oseba = serde_json:: from_str (json_data).unwrap();
// Natisnite polno ime in starost osebe
println!("Ime: {}", oseba.polno_ime);
println!("Starost: {}", oseba.starost);
}

Z označevanjem Oseba struct z #[izpelji (deserializiraj)] navedete, da lahko Serde deserializira strukturo iz JSON. The #[serde (preimenuj = "ime")] atribut preslika ime polje v JSON v polno ime polje.

The from_str funkcija deserializira json_data spremenljivko v oseba predmet in glavni funkcija natisne polja na konzolo.

Serde podpira deserializacijo različnih tipov podatkov Rust, vključno s primitivnimi tipi, enumi, ugnezdenimi strukturami in zbirkami.

Evo, kako lahko deserializirate matriko JSON v strukturo Rust, ki vsebuje vektorsko polje:

uporaba serde:: deserializiraj;
#[izpelji (deserializiraj)]
structpodatki {
 številke: Vec<u32>,
}
fnglavni() {
pustiti json_data = r#"
 {
"številke": [1, 2, 3, 4, 5]
 }
"#;
pustiti podatki: Podatki = serde_json:: from_str (json_data).unwrap();
za število v data.numbers {
println!("Številka: {}", številka);
 }
}

The glavni funkcija deserializira json_data JSON vsebino v podatke spremenljivka, zanka pa natisne elemente v vektorju.

Zagotoviti morate, da imate prave vrste podatkov in identifikatorje za postopek deserializacije.

Serde sodeluje s priljubljenimi spletnimi ogrodji Rust

Serde je zmogljiva knjižnica s številnimi funkcijami in preprostim API-jem za serializacijo in deserializacijo podatkov v različne formate.

Serde je široko sprejet v ekosistemu Rust in številni priljubljeni zaboji in ogrodja imajo vgrajene podpora za Serde, vključno s priljubljenimi spletnimi ogrodji, kot so Actix, Warp in Rocket ter ORM-ji podatkovnih baz, kot je Dizelsko gorivo.