Serializácia a deserializácia JSON s hrdzou

JSON (JavaScript Object Notation) sa objavil ako populárny formát na výmenu údajov v softvéri vývoj vďaka svojej jednoduchosti, čitateľnosti a širokej podpore v rámci rôznych programov jazykoch. JSON je odľahčená alternatíva k XML na prenos údajov medzi serverom a webovou aplikáciou alebo medzi rôznymi komponentmi softvérového systému.

Jedným z kľúčových aspektov práce s JSON je proces serializácie a deserializácie, ktorý vám umožňuje konvertovať údaje JSON do štruktúrovaného formátu, s ktorým môžete ľahko manipulovať vo svojom programy. Vo väčšine prípadov, ak chcete pracovať s JSON v iných jazykoch, možno budete musieť serializovať a deserializovať údaje JSON do vstavaných dátových štruktúr daného jazyka.

Začíname so Serde

Serde (serializácia a deserializácia) je široko používaná knižnica Rust, ktorá poskytuje rámec na konverziu Údajové štruktúry hrdze do formátov na ukladanie, prenos, zdieľanie a iné.

Serde umožňuje bezproblémovú konverziu medzi typmi údajov Rust a rôznymi formátmi na výmenu údajov vrátane JSON, YAML, BSON, CBOR, MessagePack a ďalších.

Primárnym cieľom spoločnosti Serde je čo najjednoduchší a najefektívnejší proces serializácie a deserializácie pri zachovaní silných funkcií písania a bezpečnosti.

Pridajte tieto smernice do závislosti časť vášho Cargo.toml súbor na inštaláciu a používanie Serde ako závislosť od tretích strán s Cargo.

[závislosti]
Serde = { verzia = "1.0.159", funkcie = ["odvodiť"] }
serde_json = "1.0.96"

Budete potrebovať oboje Serde a serde_json prepravky na interakciu s JSON. The Serde prepravka poskytuje základné funkcie a serde_json crate je špecifická implementácia Serde pre prácu s JSON.

Tu je návod, ako môžete importovať serde_json prepravka a Serializovať a Deserializovať moduly z Serde prepravka:

použitie serde::{Serializovať, Deserializovať};
použitie serde_json;

Celkovo je Serde výkonný nástroj, ktorý budete potrebovať vo svojom vývojovom arzenáli, ak pracujete s JSON v Ruste.

Serializácia údajov pomocou Serde

Proces serializácie JSON zahŕňa konverziu typu Rust (vlastný alebo vstavaný) na JSON pre ďalšie operácie. Serde poskytuje sadu atribútov, ktoré môžete použiť so štruktúrou Rust na umožnenie presnej kontroly nad procesom serializácie, vrátane #[odvodiť (serializovať)] atribút, ktorý vám umožňuje vygenerovať serializačný kód pre vaše dátové štruktúry a previesť vašu štruktúru Rust na JSON.

Zvážte túto štruktúru predstavujúcu osobné údaje osoby; tu je návod, ako môžete importovať a používať Serializovať atribút na štruktúre:

použitie serde::{Serializovať, Deserializovať};
použitie serde_json;
#[odvodiť (serializovať)]
štrukturovaťOsoba {
 názov: Reťazec,
 Vek: u32,
}

Pomocou anotácií Osoba štrukturovať s [#derive (Serialize)], hovoríte Serde, aby vygeneroval potrebný serializačný kód pre Osoba štrukturovať automaticky.

Tu je návod, ako môžete serializovať inštanciu súboru Osoba štruktúra do JSON:

použitie serde::{Serialize};
použitie serde_json;
fnHlavná() {
// deklarácia inštancie štruktúry Osoba s poľami meno a vek
nech osoba = Osoba {
 názov: "Chukwuemeriwo".natiahnuť(),
 Vek: 28,
 };
// serializuje štruktúru osoby do JSON pomocou knižnice serde_json
nech json = serde_json:: to_string(&person).expect("Serializácia zlyhala");
// vypíše serializovaný reťazec JSON
println!("Serializovaný JSON: {}", json);
}

V Hlavná funkcia, serde_json prepravka serializuje osoba objekt. The natiahnuť funkcia berie odkaz na osoba objekt a vráti reťazec JSON predstavujúci serializované údaje.

Nakoniec, Hlavná funkcia vytlačí serializovaný JSON do konzoly.

The Serde a serde_json sú všestranné, polia môžete tiež serializovať pomocou serde.

použitie serde::{Serializovať, Deserializovať};
použitie serde_json;
#[odvodiť (serializovať)]
štrukturovaťSúradnice {
 X: f32,
 y: f32,
}
fnHlavná() {
nech body = vec![ 
 Súradnice { x: 1.0, y: 2.0 },
 Súradnice { x: 3.5, y: 4.5 },
 ];
nech json = serde_json:: to_string(&points).expect("Serializácia zlyhala"); 
println!("Serializovaný JSON: {}", json); // Vytlačí serializovaný reťazec JSON
}

The bodov premenná je vektor Súradnice štruktúry predstavujúce body v rovine. Aplikácia Serializovať pripisovať k Súradnice struct vám umožňuje bez námahy serializovať vektor do JSON.

Okrem toho môžete zoznamy serializovať do JSON pomocou Serde ako keď serializujete štruktúry a vektory.

použitie serde::{Serializovať, Deserializovať};
použitie serde_json;
#[derive (serialize, deserialize)]
enumZviera {
 Pes(Reťazec),
 mačka(u32),
 Vták,
}
fnHlavná() {
nech pes = Zviera:: Pes("hrdzavý".natiahnuť());
nech json = serde_json:: to_string(&pes).expect("Serializácia zlyhala");
println!("Serializovaný JSON: {}", json);
}

V závislosti od variantu sa proces serializácie zodpovedajúcim spôsobom prispôsobí (v tomto prípade Zviera:: Pes variant zahŕňa a Reťazec pole, ktoré Serde serializuje ako reťazec JSON).

Deserializácia údajov pomocou Serde

Deserializácia JSON je proces transformácie údajov JSON na natívne typy údajov programovacieho jazyka. Serde poskytuje komplexný rámec pre deserializáciu JSON, ktorý funguje na väčšine vstavaných typov údajov.

Podobne ako pri serializácii, aj Serde ponúka atribúty, ktoré môžete použiť na anotáciu svojich Rust štruktúr pre proces deserializácie. Dva bežne používané atribúty pre serializáciu sú #[odvodiť (deserializovať)] a #[serde (rename = "json_field_name")] atribúty.

The #[odvodiť (deserializovať)] atribút automaticky odvodzuje implementáciu deserializácie pre váš Typy hrdzavých štruktúr, kým #[serde (rename = "json_field_name")] atribút vám umožňuje mapovať polia struct na zodpovedajúce názvy polí JSON.

Tu je návod, ako môžete deserializovať údaje JSON na vlastný typ štruktúry pomocou Serde:

použitie serde:: Deserializovať;
použitie serde_json;
// definuje štruktúru pre osobu s vlastnosťou deserializovať zo Serde
#[odvodiť (deserializovať)]
štrukturovaťOsoba {
#[serde (premenovať = "názov")]// premenuje pole na "name" 
 celé meno: Reťazec, 
 Vek: u32,
}
fnHlavná() {
nech json_data = r#"
 {
"názov": "John Doe",
"Vek": 30
 }
"#;
// deserializuje údaje JSON na štruktúru osoby 
nech osoba: Osoba = serde_json:: from_str (json_data).unwrap();
// Vytlačte celé meno a vek osoby
println!("Názov: {}", osoba.cele_meno);
println!("Vek: {}", osoba.vek);
}

Pomocou anotácií Osoba štrukturovať s #[odvodiť (deserializovať)] naznačujete, že Serde môže deserializovať štruktúru z JSON. The #[serde (premenovať = "meno")] atribút mapuje názov poľa v JSON na celé meno lúka.

The od_str funkcia deserializuje json_data premenná do osoba objekt a Hlavná funkcia vytlačí polia do konzoly.

Serde podporuje deserializáciu na rôznych typoch údajov Rust, vrátane primitívnych typov, enumov, vnorených štruktúr a kolekcií.

Tu je návod, ako môžete deserializovať pole JSON na štruktúru Rust obsahujúcu vektorové pole:

použitie serde:: Deserializovať;
#[odvodiť (deserializovať)]
štrukturovaťÚdaje {
 čísla: Vec<u32>,
}
fnHlavná() {
nech json_data = r#"
 {
"čísla": [1, 2, 3, 4, 5]
 }
"#;
nech data: Data = serde_json:: from_str (json_data).unwrap();
pre číslo v data.numbers {
println!("Číslo: {}", číslo);
 }
}

The Hlavná funkcia deserializuje json_data Obsah JSON do údajov premenná a slučka vytlačí prvky vo vektore.

Musíte zabezpečiť, aby ste mali správne typy údajov a identifikátory pre proces deserializácie.

Serde spolupracuje s populárnymi webovými rámcami Rust

Serde je výkonná knižnica s mnohými funkciami a jednoduchým API na serializáciu a deserializáciu údajov do rôznych formátov.

Serde je široko adoptovaný v ekosystéme Rust a má zabudované mnoho populárnych prepraviek a rámov podpora pre Serde, vrátane populárnych webových rámcov ako Actix, Warp a Rocket a databázových ORM ako Diesel.