JSON-serialisatie en deserialisatie met Rust

JSON (JavaScript Object Notation) is naar voren gekomen als een populair formaat voor gegevensuitwisseling in software ontwikkeling vanwege de eenvoud, leesbaarheid en brede ondersteuning voor verschillende programmeringen talen. JSON is een lichtgewicht alternatief voor XML voor het verzenden van gegevens tussen een server en een webapplicatie of tussen verschillende softwaresysteemcomponenten.

Een van de belangrijkste aspecten van het werken met JSON is het proces van serialisatie en deserialisatie stelt u in staat om JSON-gegevens om te zetten in een gestructureerd formaat dat u gemakkelijk kunt manipuleren binnen uw programma's. Als u met JSON in andere talen wilt werken, moet u meestal de JSON-gegevens serialiseren en deserialiseren naar de ingebouwde datastructuren van de taal.

Aan de slag met Serde

Serde (serialisatie en deserialisatie) is een veelgebruikte Rust-bibliotheek die een raamwerk biedt voor het converteren van

Roestige datastructuren in formaten voor opslag, verzending, delen en andere.

Serde maakt naadloze conversie mogelijk tussen Rust-gegevenstypen en verschillende indelingen voor gegevensuitwisseling, waaronder JSON, YAML, BSON, CBOR, MessagePack en andere.

De primaire focus van Serde is om het serialisatie- en deserialisatieproces zo eenvoudig en efficiënt mogelijk te maken met behoud van krachtige type- en veiligheidskenmerken.

Voeg deze richtlijnen toe aan de afhankelijkheden gedeelte van uw Cargo.toml bestand om te installeren en te gebruiken Serde als een afhankelijkheid van derden met Cargo.

[afhankelijkheden]
serde = { versie = "1.0.159", kenmerken = ["afleiden"] }
serde_json = "1.0.96"

Je hebt beide nodig serde En serde_json kratten om te communiceren met JSON. De serde krat biedt de kernfunctionaliteiten en de serde_json krat is een specifieke implementatie van Serde voor het werken met JSON.

Hier leest u hoe u de serde_json krat en de Serialiseren En Deserialiseren modules uit de serde krat:

gebruik serde::{Serialiseren, Deserialiseren};
gebruik serde_json;

Over het algemeen is Serde een krachtige tool die je nodig hebt in je ontwikkelingsarsenaal als je met JSON in Rust werkt.

Gegevensserialisatie met Serde

Het JSON-serialisatieproces omvat het converteren van een Rust-type (aangepast of ingebouwd) naar JSON voor andere bewerkingen. Serde biedt een set attributen die u met Rust struct kunt gebruiken om nauwkeurige controle over het serialisatieproces mogelijk te maken, inclusief de #[afleiden (serialiseren)] attribuut waarmee u serialisatiecode voor uw datastructuren kunt genereren en uw Rust-structuur naar JSON kunt converteren.

Overweeg deze structuur die de biogegevens van een persoon vertegenwoordigt; hier ziet u hoe u de Serialiseren attribuut op de structuur:

gebruik serde::{Serialiseren, Deserialiseren};
gebruik serde_json;
#[afleiden (serialiseren)]
structuurPersoon {
 naam: Snaar,
 leeftijd: u32,
}

Door het annoteren van de Persoon struct met de [#afleiden (serialiseren)], vertel je Serde om de benodigde serialisatiecode te genereren voor de Persoon automatisch structureren.

Hier ziet u hoe u een instantie van de Persoon struct naar JSON:

gebruik serde::{Serialiseren};
gebruik serde_json;
fnvoornaamst() {
// declaratie van de Person struct-instantie met de naam- en leeftijdsvelden
laten persoon = Persoon {
 naam: "Chukwuemeriwo".to_string(),
 leeftijd: 28,
 };
// serialiseert de persoonsstructuur naar JSON met behulp van de serde_json-bibliotheek
laten json = serde_json:: to_string(&person).expect("Serialisatie mislukt");
// drukt de geserialiseerde JSON-string af
println!("Geserialiseerd JSON: {}", json);
}

In de voornaamst functie, de serde_json krat serialiseert de persoon voorwerp. De naar_tekenreeks functie neemt een verwijzing naar de persoon object en retourneert een JSON-tekenreeks die de geserialiseerde gegevens vertegenwoordigt.

eindelijk, de voornaamst functie drukt de geserialiseerde JSON af naar de console.

De serde En serde_json zijn veelzijdig, u kunt ook arrays serialiseren met serde.

gebruik serde::{Serialiseren, Deserialiseren};
gebruik serde_json;
#[afleiden (serialiseren)]
structuurCoördinaten {
 X: f32,
 j: f32,
}
fnvoornaamst() {
laten punten = vec![ 
 Coördinaten X: 1.0, j: 2.0 },
 Coördinaten X: 3.5, j: 4.5 },
 ];
laten json = serde_json:: to_string(&punten).expect("Serialisatie mislukt"); 
println!("Geserialiseerd JSON: {}", json); // Druk de geserialiseerde JSON-string af
}

De punten variabele is een vector van Coördinaten structuren die punten op een vlak voorstellen. Het toepassen van de Serialiseren toeschrijven aan de Coördinaten struct stelt u in staat om de vector moeiteloos naar JSON te serialiseren.

Bovendien kunt u opsommingen in JSON serialiseren met serde zoals je structs en vectoren serialiseert.

gebruik serde::{Serialiseren, Deserialiseren};
gebruik serde_json;
#[afleiden (serialiseren, deserialiseren)]
opsommingDier {
 Hond(Snaar),
 Kat(u32),
 Vogel,
}
fnvoornaamst() {
laten hond = Dier:: Hond("Roestig".to_string());
laten json = serde_json:: to_string(&dog).expect("Serialisatie mislukt");
println!("Geserialiseerd JSON: {}", json);
}

Afhankelijk van de variant past het serialisatieproces zich dienovereenkomstig aan (in dit geval de Dier:: Hond variant omvat een Snaar veld dat Serde zal serialiseren als een JSON-tekenreeks).

Gegevensdeserialisatie met Serde

JSON-deserialisatie is het proces waarbij JSON-gegevens worden omgezet in native gegevenstypen van een programmeertaal. Serde biedt een uitgebreid raamwerk voor JSON-deserialisatie dat werkt op de meeste ingebouwde gegevenstypen.

Net als bij serialisatie biedt Serde attributen die u kunt gebruiken om uw Rust-structuren te annoteren voor het deserialisatieproces. Twee veelgebruikte attributen voor serialisatie zijn de #[afleiden (Deserialiseren)] En #[serde (hernoemen = "json_field_name")] attributen.

De #[afleiden (Deserialiseren)] attribuut leidt automatisch de deserialisatie-implementatie voor uw Rust structuur typen, Terwijl de #[serde (hernoemen = "json_field_name")] attribuut stelt u in staat om struct-velden toe te wijzen aan overeenkomstige JSON-veldnamen.

Hier leest u hoe u JSON-gegevens kunt deserialiseren naar een aangepast structuurtype met Serde:

gebruik serde:: Deserialiseren;
gebruik serde_json;
// definieert een structuur voor Persoon met de eigenschap Deserialiseren van Serde
#[afleiden (Deserialiseren)]
structuurPersoon {
#[serde (hernoemen = "naam")]// hernoemt het veld naar "naam" 
 voor-en achternaam: Snaar, 
 leeftijd: u32,
}
fnvoornaamst() {
laten json_data = r#"
 {
"naam": "John Doe",
"leeftijd": 30
 }
"#;
// deserialiseert de JSON-gegevens naar een Person-structuur 
laten persoon: Persoon = serde_json:: from_str (json_data).unwrap();
// Druk de volledige naam en leeftijd van de persoon af
println!("Naam: {}", persoon.volledige_naam);
println!("Leeftijd: {}", persoon.leeftijd);
}

Door het annoteren van de Persoon struct met de #[afleiden (Deserialiseren)] attribuut, geeft u aan dat Serde de structuur van JSON kan deserialiseren. De #[serde (hernoemen = "naam")] attribuut brengt de naam veld in de JSON naar de voor-en achternaam veld.

De van_str functie deserialiseert de json_gegevens variabele in de persoon voorwerp, en de voornaamst functie drukt de velden af ​​naar de console.

Serde ondersteunt deserialisatie op verschillende Rust-gegevenstypen, waaronder primitieve typen, opsommingen, geneste structuren en verzamelingen.

Hier leest u hoe u een JSON-array kunt deserialiseren naar een Rust-structuur die een vectorveld bevat:

gebruik serde:: Deserialiseren;
#[afleiden (Deserialiseren)]
structuurGegevens {
 nummers: Vec<u32>,
}
fnvoornaamst() {
laten json_data = r#"
 {
"nummers": [1, 2, 3, 4, 5]
 }
"#;
laten gegevens: Gegevens = serde_json:: from_str (json_data).unwrap();
voor nummer in data.nummers {
println!("Nummer: {}", nummer);
 }
}

De voornaamst functie deserialiseert de json_gegevens JSON-inhoud in de gegevens variabele en de lus drukt de elementen in de vector af.

U moet ervoor zorgen dat u over de juiste gegevenstypen en identifiers beschikt voor een deserialisatieproces.

Serde werkt samen met populaire Rust-webframeworks

Serde is een krachtige bibliotheek met veel functies en een eenvoudige API voor het serialiseren en deserialiseren van gegevens in verschillende formaten.

Serde wordt algemeen toegepast in het Rust-ecosysteem en veel populaire kratten en raamwerken zijn ingebouwd ondersteuning voor Serde, inclusief populaire webframeworks zoals Actix, Warp en Rocket en database-ORM's zoals Diesel.