JSON (JavaScript Object Notation) est devenu un format d’échange de données populaire dans le développement de logiciels en raison de sa simplicité, de sa lisibilité et de sa prise en charge généralisée dans divers langages de programmation. 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 d’un système logiciel.
L’un des principaux aspects du travail avec JSON est le processus de sérialisation et de désérialisation qui vous permet de convertir les données JSON dans un format structuré que vous pouvez facilement manipuler dans vos programmes. La plupart du temps, si vous souhaitez travailler avec JSON dans d’autres langages, vous devrez sérialiser et désérialiser les données JSON dans les structures de données intégrées du langage.
Démarrer avec Serde
Serde (serialization and deserialization) est une bibliothèque Rust largement utilisée qui fournit un cadre pour convertir les structures de données Rust 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, etc.
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 caractéristiques de typage et de sécurité solides.
Ajouter ces directives au fichier dépendances de votre Cargo.toml fichier à installer et à utiliser Serde comme dépendance tierce avec Cargo.
[dependencies]
serde = { version = "1.0.159" , features = ["derive"] }
serde_json = "1.0.96"
Vous aurez besoin à la fois de l’extension serde et serde_json crates pour interagir avec JSON. Les serde crate fournit les fonctionnalités de base, et l’application serde_json crate est une implémentation spécifique de Serde pour travailler avec JSON.
Voici comment vous pouvez importer le serde_json la caisse et le Serialize et Désérialiser Les modules de la base de données serde crate :
use serde::{Serialize, Deserialize};
use 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 en Rust.
La 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 Rust struct pour permettre un contrôle précis du processus de sérialisation, y compris les attributs suivants #[derive(Serialize)] qui vous permet de générer du code de sérialisation pour vos structures de données et de convertir vos structures Rust en JSON.
Considérons cette structure représentant les données biologiques d’une personne ; voici comment vous pouvez importer et utiliser l’attribut Sérialiser sur la structure :
use serde::{Serialize, Deserialize};
use serde_json;
#[derive(Serialize)]
struct Person {
name: String,
age: u32,
}
En annotant l’attribut Personne struct avec le [#derive(Serialize)]vous dites à Serde de générer le code de sérialisation nécessaire pour la structure Personne struct automatiquement.
Voici comment sérialiser une instance de la structure Personne struct en JSON :
use serde::{Serialize};
use serde_json;
fn main() {
// declaration of the Person struct instance with the name and age fields
let person = Person {
name: "Chukwuemeriwo".to_string(),
age: 28,
};
// serializes the person struct to JSON using the serde_json library
let json = serde_json::to_string(&person).expect("Serialization failed");
// prints the serialized JSON string
println!("Serialized JSON: {}", json);
}
Dans la page principal la fonction serde_json crate sérialise le fichier personne objet. L’objet to_string prend une référence à la fonction personne et renvoie une chaîne JSON représentant les données sérialisées.
Enfin, la fonction principal imprime le JSON sérialisé sur la console.
Le serde et serde_json sont polyvalents, vous pouvez également sérialiser des tableaux avec serde.
use serde::{Serialize, Deserialize};
use serde_json;
#[derive(Serialize)]
struct Coordinates {
x: f32,
y: f32,
}
fn main() {
let points = vec![
Coordinates { x: 1.0, y: 2.0 },
Coordinates { x: 3.5, y: 4.5 },
];
let json = serde_json::to_string(&points).expect("Serialization failed");
println!("Serialized JSON: {}", json); // Print the serialized JSON string
}
Le points variable est un vecteur de Coordonnées structures représentant des points sur un plan. En appliquant les Sérialiser à l’attribut Coordonnées vous permet de sérialiser le vecteur en JSON sans effort.
De plus, vous pouvez sérialiser les enums en JSON avec serde comme on sérialise les structs et les vecteurs.
use serde::{Serialize, Deserialize};
use serde_json;
#[derive(Serialize, Deserialize)]
enum Animal {
Dog(String),
Cat(u32),
Bird,
}
fn main() {
let dog = Animal::Dog("Rusty".to_string());
let json = serde_json::to_string(&dog).expect("Serialization failed");
println!("Serialized JSON: {}", json);
}
En fonction de la variante, le processus de sérialisation s’adapte en conséquence (dans ce cas, la fonction Animal::Chien La variante comprend un Chaîne que Serde sérialisera sous forme de 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.
Comme pour 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 attributs #[derive(Deserialize)] et #[serde(rename = « json_field_name »)] attributs.
Les #[derive(Deserialize)] dérive automatiquement l’implémentation de la désérialisation pour vos types struct Rust, tandis que l’attribut #[serde(rename = « json_field_name »)] permet de faire correspondre des champs struct à des noms de champs JSON.
Voici comment désérialiser des données JSON dans un type struct personnalisé avec Serde :
use serde::Deserialize;
use serde_json;
// defines a struct for Person with the Deserialize trait from Serde
#[derive(Deserialize)]
struct Person {
#[serde(rename = "name")] // renames the field to "name"
full_name: String,
age: u32,
}
fn main() {
let json_data = r#"
{
"name": "John Doe",
"age": 30
}
"#;
// deserializes the JSON data into a Person struct
let person: Person = serde_json::from_str(json_data).unwrap();
// Print the full name and age of the person
println!("Name: {}", person.full_name);
println!("Age: {}", person.age);
}
En annotant l’élément Personne struct avec le #[derive(Deserialize)] vous indiquez que Serde peut désérialiser la structure à partir de JSON. L’attribut #[serde(rename = « name »)] L’attribut nom dans le JSON vers le champ nom_complet champ.
Le from_str désérialise la chaîne de caractères json_data dans la variable personne et l’objet principal imprime les champs sur la console.
Serde supporte la désérialisation sur différents types de données Rust, y compris les types primitifs, les enums, les structures imbriquées et les collections.
Voici comment désérialiser un tableau JSON en une structure Rust contenant un champ vectoriel :
use serde::Deserialize;
#[derive(Deserialize)]
struct Data {
numbers: Vec<u32>,
}
fn main() {
let json_data = r#"
{
"numbers": [1, 2, 3, 4, 5]
}
"#;
let data: Data = serde_json::from_str(json_data).unwrap();
for number in data.numbers {
println!("Number: {}", number);
}
}
La fonction principal désérialise le fichier json_data Contenu JSON dans le fichier données et la boucle imprime les éléments du vecteur.
Vous devez vous assurer que vous avez les bons types de données et les bons identifiants pour un processus de désérialisation.
Serde interagit avec les frameworks Web Rust les plus populaires
Serde est une bibliothèque puissante avec de nombreuses fonctionnalités et une API simple pour sérialiser et désérialiser des données dans différents formats.
Serde est largement adopté dans l’écosystème Rust, et de nombreux crates et frameworks populaires ont un support intégré pour Serde, y compris des frameworks web populaires comme Actix, Warp, et Rocket et des ORMs de base de données comme Diesel.
