Serializare și deserializare JSON cu Rust

JSON (JavaScript Object Notation) a apărut ca un format popular de schimb de date în software dezvoltare datorită simplității, lizibilității și suportului larg răspândit în diverse programe limbi. JSON este o alternativă ușoară la XML pentru transmiterea datelor între un server și o aplicație web sau între diferite componente ale sistemului software.

Unul dintre aspectele cheie ale lucrului cu JSON este procesul de serializare și deserializare care vă permite să convertiți datele JSON într-un format structurat pe care îl puteți manipula cu ușurință în interiorul dvs programe. De cele mai multe ori, dacă doriți să lucrați cu JSON în alte limbi, poate fi necesar să serializați și să deserializați datele JSON în structurile de date încorporate în limbaj.

Începeți cu Serde

Serde (serializare și deserializare) este o bibliotecă Rust utilizată pe scară largă care oferă un cadru pentru conversie

Rugină structuri de date în formate pentru stocare, transmitere, partajare și altele.

Serde permite conversia fără întreruperi între tipurile de date Rust și diferite formate de schimb de date, inclusiv JSON, YAML, BSON, CBOR, MessagePack și altele.

Obiectivul principal al Serde este de a face procesul de serializare și deserializare cât mai simplu și eficient posibil, menținând în același timp caracteristici puternice de tastare și siguranță.

Adăugați aceste directive la dependențe secțiunea dvs Marfă.toml fișier de instalat și utilizat Serde ca dependență de terți cu Cargo.

[dependențe]
serde = { versiunea = "1.0.159", caracteristici = ["deriva"] }
serde_json = "1.0.96"

Veți avea nevoie de ambele serde și serde_json lăzi pentru a interacționa cu JSON. The serde crate oferă funcționalitățile de bază, iar serde_json crate este o implementare specifică a Serde pentru lucrul cu JSON.

Iată cum puteți importa serde_json ladă şi Serializați și Deserializați module din serde ladă:

utilizare serde::{Serializare, deserializare};
utilizare serde_json;

În general, Serde este un instrument puternic de care veți avea nevoie în arsenalul de dezvoltare dacă lucrați cu JSON în Rust.

Serializarea datelor cu Serde

Procesul de serializare JSON presupune conversia unui tip Rust (personalizat sau încorporat) în JSON pentru alte operațiuni. Serde oferă un set de atribute pe care le puteți utiliza cu Rust struct pentru a permite controlul precis asupra procesului de serializare, inclusiv #[derivare (serializare)] atribut care vă permite să generați cod de serializare pentru structurile dvs. de date și să convertiți structura Rust în JSON.

Luați în considerare această structură reprezentând datele biologice ale unei persoane; iată cum puteți importa și utiliza Serializați atribut pe structura:

utilizare serde::{Serializare, deserializare};
utilizare serde_json;
#[derivare (serializare)]
structPersoană {
 Nume: Şir,
 vârstă: u32,
}

Prin adnotarea Persoană struct cu [#deriva (serializare)], îi spui lui Serde să genereze codul de serializare necesar pentru Persoană struct automat.

Iată cum puteți serializa o instanță a Persoană struct în JSON:

utilizare serde::{Serializare};
utilizare serde_json;
fnprincipal() {
// declarația instanței struct Person cu câmpurile de nume și vârstă
lăsa persoană = Persoană {
 Nume: „Chukwuemeriwo”.to_string(),
 vârstă: 28,
 };
// serializează structura persoană în JSON folosind biblioteca serde_json
lăsa json = serde_json:: to_string(&person).expect(„Serializarea a eșuat”);
// tipărește șirul JSON serializat
println!(„JSON serializat: {}”, json);
}

În principal funcția, cea serde_json crate serializează persoană obiect. The to_string funcția ia o referință la persoană obiect și returnează un șir JSON reprezentând datele serializate.

În cele din urmă, cel principal funcția imprimă JSON serializat pe consolă.

The serde și serde_json sunt versatile, puteți, de asemenea, serializa matrice cu serde.

utilizare serde::{Serializare, deserializare};
utilizare serde_json;
#[derivare (serializare)]
structCoordonatele {
 X: f32,
 y: f32,
}
fnprincipal() {
lăsa puncte = vec![ 
 Coordonate { x: 1.0, y: 2.0 },
 Coordonate { x: 3.5, y: 4.5 },
 ];
lăsa json = serde_json:: to_string(&points).expect(„Serializarea a eșuat”); 
println!(„JSON serializat: {}”, json); // Imprimă șirul JSON serializat
}

The puncte variabila este un vector al Coordonatele structuri reprezentând puncte de pe un plan. Aplicarea Serializați atribuie Coordonatele struct vă permite să serializați vectorul în JSON fără efort.

În plus, puteți serializa enumerarea în JSON cu serde cum serializați structuri și vectori.

utilizare serde::{Serializare, deserializare};
utilizare serde_json;
#[derivare (serializare, deserializare)]
enumerareAnimal {
 Câine(Şir),
 Pisică(u32),
 Pasăre,
}
fnprincipal() {
lăsa câine = animal:: câine("Ruginit".to_string());
lăsa json = serde_json:: to_string(&dog).expect(„Serializarea a eșuat”);
println!(„JSON serializat: {}”, json);
}

În funcție de variantă, procesul de serializare se adaptează în consecință (în acest caz, sistemul Animal:: Câine varianta include a Şir câmp pe care Serde îl va serializa ca șir JSON).

Deserializarea datelor cu Serde

Deserializarea JSON este procesul de transformare a datelor JSON în tipuri de date native ale unui limbaj de programare. Serde oferă un cadru cuprinzător pentru deserializarea JSON care funcționează pe majoritatea tipurilor de date încorporate.

Similar cu serializarea, Serde oferă atribute pe care le puteți utiliza pentru a adnota structurile Rust pentru procesul de deserializare. Două atribute utilizate în mod obișnuit pentru serializare sunt #[derivare (deserializare)] și #[serde (rename = "json_field_name")] atribute.

The #[derivare (deserializare)] atributul derivă automat implementarea deserializării pentru dvs Tipuri de rugini, in timp ce #[serde (rename = "json_field_name")] attribute vă permite să mapați câmpurile struct cu numele de câmpuri JSON corespunzătoare.

Iată cum puteți deserializa datele JSON într-un tip de structură personalizat cu Serde:

utilizare serde:: Deserialize;
utilizare serde_json;
// definește o structură pentru Persoană cu trăsătura Deserialize de la Serde
#[derivare (deserializare)]
structPersoană {
#[serde (redenumiți = "Nume")]// redenumește câmpul în „nume” 
 Numele complet: Şir, 
 vârstă: u32,
}
fnprincipal() {
lăsa json_data = r#"
 {
"Nume": „John Doe”,
"vârstă": 30
 }
"#;
// deserializează datele JSON într-o structură Person 
lăsa person: Person = serde_json:: from_str (json_data).unwrap();
// Tipăriți numele complet și vârsta persoanei
println!("Nume: {}", persoana.nume_complet);
println!(„Vârsta: {}”, persoana.varsta);
}

Prin adnotarea Persoană struct cu #[derivare (deserializare)] atribut, indicați că Serde poate deserializa structura din JSON. The #[serde (rename = "nume")] atributul mapează Nume câmpul din JSON la Numele complet camp.

The din_str funcția deserializează json_data variabilă în persoană obiect, iar principal funcția imprimă câmpurile pe consolă.

Serde acceptă deserializarea pe diferite tipuri de date Rust, inclusiv tipuri primitive, enumerari, structuri imbricate și colecții.

Iată cum puteți deserializa o matrice JSON într-o structură Rust care conține un câmp vectorial:

utilizare serde:: Deserialize;
#[derivare (deserializare)]
structDate {
 numere: Vec<u32>,
}
fnprincipal() {
lăsa json_data = r#"
 {
"numerele": [1, 2, 3, 4, 5]
 }
"#;
lăsa date: Data = serde_json:: from_str (json_data).unwrap();
pentru număr în date.numbers {
println!("Număr: {}", număr);
 }
}

The principal funcția deserializează json_data Conținut JSON în date variabilă, iar bucla imprimă elementele din vector.

Trebuie să vă asigurați că aveți tipurile de date și identificatorii potriviți pentru un proces de deserializare.

Serde interoperează cu cadre populare Rust Web

Serde este o bibliotecă puternică, cu multe caracteristici și un API simplu pentru serializarea și deserializarea datelor în diferite formate.

Serde este adoptat pe scară largă în ecosistemul Rust și multe lăzi și cadre populare au încorporat suport pentru Serde, inclusiv cadre web populare precum Actix, Warp și Rocket și ORM-uri de baze de date precum Motorină.