Sérialisation et désérialisation JSON avec Rust

JSON (JavaScript Object Notation) est devenu un format d'échange de données populaire dans les logiciels développement en raison de sa simplicité, de sa lisibilité et de sa prise en charge généralisée dans divers programmes langues. JSON est une alternative légère à XML pour la transmission de données entre un serveur et une application Web ou entre différents composants du système logiciel.

L'un des aspects clés du travail avec JSON est le processus de sérialisation et de désérialisation qui vous permet de convertir des données JSON dans un format structuré que vous pouvez facilement manipuler dans votre programmes. La plupart du temps, si vous souhaitez travailler avec JSON dans d'autres langages, vous devrez peut-être sérialiser et désérialiser les données JSON dans les structures de données intégrées du langage.

Premiers pas avec Serde

Serde (sérialisation et désérialisation) est une bibliothèque Rust largement utilisée qui fournit un cadre pour la conversion Structures de données rouillées dans des formats de stockage, de transmission, de partage et autres.

Serde permet une conversion transparente entre les types de données Rust et divers formats d'échange de données, notamment JSON, YAML, BSON, CBOR, MessagePack et autres.

L'objectif principal de Serde est de rendre le processus de sérialisation et de désérialisation aussi simple et efficace que possible tout en conservant des fonctions de frappe et de sécurité solides.

Ajoutez ces directives au dépendances rubrique de votre Cargaison.toml fichier à installer et à utiliser Serde comme un dépendance de tiers avec Cargo.

[dépendances]
serde = { version = "1.0.159", caractéristiques = ["dériver"] }
serde_json = "1.0.96"

Vous aurez besoin à la fois du serde et serde_json crates pour interagir avec JSON. Le serde crate fournit les fonctionnalités de base, et le serde_json crate est une implémentation spécifique de Serde pour travailler avec JSON.

Voici comment vous pouvez importer le serde_json caisse et la Sérialiser et Désérialiser module de la serde Caisse:

utiliser serde ::{Sérialiser, Désérialiser} ;
utiliser serde_json;

Dans l'ensemble, Serde est un outil puissant dont vous aurez besoin dans votre arsenal de développement si vous travaillez avec JSON dans Rust.

Sérialisation des données avec Serde

Le processus de sérialisation JSON implique la conversion d'un type Rust (personnalisé ou intégré) en JSON pour d'autres opérations. Serde fournit un ensemble d'attributs que vous pouvez utiliser avec la structure Rust pour permettre un contrôle précis du processus de sérialisation, y compris le #[dériver (sérialiser)] attribut qui vous permet de générer du code de sérialisation pour vos structures de données et de convertir votre structure Rust en JSON.

Considérez cette structure représentant les données biographiques d'une personne; Voici comment vous pouvez importer et utiliser le Sérialiser attribut sur la structure :

utiliser serde ::{Sérialiser, Désérialiser} ;
utiliser serde_json;
#[dériver (sérialiser)]
structurePersonne {
 nom: Chaîne,
 âge: u32,
}

En annotant le Personne structure avec le [#dériver (sérialiser)], vous dites à Serde de générer le code de sérialisation nécessaire pour le Personne structure automatiquement.

Voici comment vous pouvez sérialiser une instance de Personne structure en JSON :

utiliser serde ::{Sérialiser} ;
utiliser serde_json;
fnprincipal() {
// déclaration de l'instance de la structure Person avec les champs name et age
laisser personne = Personne {
 nom: "Chukwuemeriwo".to_string(),
 âge: 28,
 };
// sérialise la structure person en JSON à l'aide de la bibliothèque serde_json
laisser json = serde_json:: to_string(&person).expect("La sérialisation a échoué");
// imprime la chaîne JSON sérialisée
imprimez !("JSON sérialisé: {}", json);
}

Dans le principal fonction, la serde_json crate sérialise le personne objet. Le to_string fonction prend une référence à la personne objet et renvoie une chaîne JSON représentant les données sérialisées.

Finalement, le principal La fonction imprime le JSON sérialisé sur la console.

Le serde et serde_json sont polyvalents, vous pouvez également sérialiser des tableaux avec serde.

utiliser serde ::{Sérialiser, Désérialiser} ;
utiliser serde_json;
#[dériver (sérialiser)]
structureCoordonnées {
 X: f32,
 y: f32,
}
fnprincipal() {
laisser points = vec![ 
 Coordonnées X: 1.0, y: 2.0 },
 Coordonnées X: 3.5, y: 4.5 },
 ];
laisser json = serde_json:: to_string(&points).expect("La sérialisation a échoué"); 
imprimez !("JSON sérialisé: {}", json); // Imprime la chaîne JSON sérialisée
}

Le points la variable est un vecteur de Coordonnées structures représentant des points sur un plan. Appliquer le Sérialiser attribuer à la Coordonnées struct vous permet de sérialiser le vecteur en JSON sans effort.

De plus, vous pouvez sérialiser les énumérations en JSON avec serde comme vous sérialisez les structures et les vecteurs.

utiliser serde ::{Sérialiser, Désérialiser} ;
utiliser serde_json;
#[dériver (sérialiser, désérialiser)]
énumérationAnimal {
 Chien(Chaîne),
 Chat(u32),
 Oiseau,
}
fnprincipal() {
laisser chien = Animal:: Chien("Rouillé".to_string());
laisser json = serde_json:: to_string(&dog).expect("La sérialisation a échoué");
imprimez !("JSON sérialisé: {}", json);
}

Selon la variante, le processus de sérialisation s'adapte en conséquence (dans ce cas, le Animaux:: Chien la variante comprend un Chaîne champ que Serde va sérialiser en tant que chaîne JSON).

Désérialisation des données avec Serde

La désérialisation JSON est le processus de transformation des données JSON en types de données natifs d'un langage de programmation. Serde fournit un cadre complet pour la désérialisation JSON qui fonctionne sur la plupart des types de données intégrés.

Semblable à la sérialisation, Serde propose des attributs que vous pouvez utiliser pour annoter vos structures Rust pour le processus de désérialisation. Deux attributs couramment utilisés pour la sérialisation sont les #[dériver (Désérialiser)] et #[serde (rename = "json_field_name")] les attributs.

Le #[dériver (Désérialiser)] l'attribut dérive automatiquement l'implémentation de la désérialisation pour votre Types de structure de rouille, tandis que le #[serde (rename = "json_field_name")] L'attribut vous permet de mapper les champs struct aux noms de champs JSON correspondants.

Voici comment vous pouvez désérialiser les données JSON dans un type de structure personnalisé avec Serde :

utiliser serde:: Désérialiser ;
utiliser serde_json;
// définit une structure pour Person avec le trait Deserialize de Serde
#[dériver (Désérialiser)]
structurePersonne {
#[serde (renommer = "nom")]// renomme le champ en "nom" 
 nom et prénom: Chaîne, 
 âge: u32,
}
fnprincipal() {
laisser json_data = r#"
 {
"nom": "John Doe",
"âge": 30
 }
"#;
// désérialise les données JSON dans une structure Person 
laisser personne: Personne = serde_json:: from_str (json_data).unwrap();
// Affiche le nom complet et l'âge de la personne
imprimez !("Nom: {}", personne.nom_complet);
imprimez !("Âge: {}", personne.age);
}

En annotant le Personne structure avec le #[dériver (Désérialiser)], vous indiquez que Serde peut désérialiser la structure de JSON. Le #[serde (renommer = "nom")] l'attribut mappe le nom champ dans le JSON au nom et prénom champ.

Le from_str la fonction désérialise le json_data variable dans le personne objet, et le principal La fonction imprime les champs sur la console.

Serde prend en charge la désérialisation sur divers types de données Rust, y compris les types primitifs, les énumérations, les structures imbriquées et les collections.

Voici comment vous pouvez désérialiser un tableau JSON dans une structure Rust contenant un champ vectoriel :

utiliser serde:: Désérialiser ;
#[dériver (Désérialiser)]
structureDonnées {
 Nombres: Vec<u32>,
}
fnprincipal() {
laisser json_data = r#"
 {
"Nombres": [1, 2, 3, 4, 5]
 }
"#;
laisser données: Données = serde_json:: from_str (json_data).unwrap();
pour nombre dans data.numbers {
imprimez !("Nombre: {}", nombre);
 }
}

Le principal la fonction désérialise le json_data contenu JSON dans le données variable, et la boucle imprime les éléments dans le vecteur.

Vous devez vous assurer que vous disposez des types de données et des identifiants appropriés pour un processus de désérialisation.

Serde interagit avec les frameworks Web Rust populaires

Serde est une bibliothèque puissante avec de nombreuses fonctionnalités et une API simple pour la sérialisation et la désérialisation des données dans différents formats.

Serde est largement adopté dans l'écosystème Rust, et de nombreuses caisses et cadres populaires ont intégré prise en charge de Serde, y compris les frameworks Web populaires comme Actix, Warp et Rocket et les ORM de base de données comme Diesel.