JSON-Serialisierung und Deserialisierung mit Rust

JSON (JavaScript Object Notation) hat sich zu einem beliebten Datenaustauschformat in Software entwickelt Entwicklung aufgrund seiner Einfachheit, Lesbarkeit und breiten Unterstützung für verschiedene Programmierungen Sprachen. JSON ist eine leichte Alternative zu XML für die Übertragung von Daten zwischen einem Server und einer Webanwendung oder zwischen verschiedenen Softwaresystemkomponenten.

Einer der Schlüsselaspekte bei der Arbeit mit JSON ist der Prozess der Serialisierung und Deserialisierung ermöglicht Ihnen die Konvertierung von JSON-Daten in ein strukturiertes Format, das Sie problemlos in Ihrem System bearbeiten können Programme. Wenn Sie mit JSON in anderen Sprachen arbeiten möchten, müssen Sie die JSON-Daten in den meisten Fällen in den integrierten Datenstrukturen der Sprache serialisieren und deserialisieren.

Erste Schritte mit Serde

Serde (Serialisierung und Deserialisierung) ist eine weit verbreitete Rust-Bibliothek, die ein Framework für die Konvertierung bereitstellt Rust-Datenstrukturen in Formate zur Speicherung, Übertragung, Weitergabe usw. umwandeln.

Serde ermöglicht die nahtlose Konvertierung zwischen Rust-Datentypen und verschiedenen Datenaustauschformaten, einschließlich JSON, YAML, BSON, CBOR, MessagePack und anderen.

Das Hauptaugenmerk von Serde liegt darauf, den Serialisierungs- und Deserialisierungsprozess so einfach und effizient wie möglich zu gestalten und gleichzeitig starke Typisierungs- und Sicherheitsfunktionen beizubehalten.

Fügen Sie diese Anweisungen zum hinzu Abhängigkeiten Abschnitt Ihres Cargo.toml Datei zur Installation und Verwendung Serde Als ein Abhängigkeit von Dritten mit Cargo.

[Abhängigkeiten]
serde = {Version = "1.0.159", Funktionen = ["ableiten"] }
serde_json = "1.0.96"

Sie benötigen beide serde Und serde_json Kisten zur Interaktion mit JSON. Der serde Kiste stellt die Kernfunktionen bereit und die serde_json Crate ist eine spezielle Implementierung von Serde für die Arbeit mit JSON.

So können Sie das importieren serde_json Kiste und die Serialisieren Und Deserialisieren Module aus der serde Kiste:

verwenden serde::{Serialisieren, Deserialisieren};
verwenden serde_json;

Insgesamt ist Serde ein leistungsstarkes Tool, das Sie in Ihrem Entwicklungsarsenal benötigen, wenn Sie mit JSON in Rust arbeiten.

Datenserialisierung mit Serde

Der JSON-Serialisierungsprozess umfasst die Konvertierung eines Rust-Typs (benutzerdefiniert oder integriert) in JSON für andere Vorgänge. Serde bietet eine Reihe von Attributen, die Sie mit der Rust-Struktur verwenden können, um eine präzise Kontrolle über den Serialisierungsprozess zu ermöglichen, einschließlich der #[ableiten (serialisieren)] Attribut, mit dem Sie Serialisierungscode für Ihre Datenstrukturen generieren und Ihre Rust-Struktur in JSON konvertieren können.

Betrachten Sie diese Struktur, die die Biodaten einer Person darstellt. Hier erfahren Sie, wie Sie das importieren und verwenden können Serialisieren Attribut auf der Struktur:

verwenden serde::{Serialisieren, Deserialisieren};
verwenden serde_json;
#[ableiten (serialisieren)]
StrukturPerson {
 Name: Zeichenfolge,
 Alter: u32,
}

Durch Kommentieren der Person Struktur mit dem [#derive (Serialisieren)], weisen Sie Serde an, den erforderlichen Serialisierungscode für zu generieren Person automatisch strukturieren.

So können Sie eine Instanz von serialisieren Person Struktur zu JSON:

verwenden serde::{Serialisieren};
verwenden serde_json;
fnhauptsächlich() {
// Deklaration der Person-Strukturinstanz mit den Feldern „Name“ und „Alter“.
lassen person = Person {
 Name: „Chukwuemeriwo“.to_string(),
 Alter: 28,
 };
// serialisiert die Personenstruktur mithilfe der serde_json-Bibliothek in JSON
lassen json = serde_json:: to_string(&person).expect(„Serialisierung fehlgeschlagen“);
// druckt die serialisierte JSON-Zeichenfolge
println!(„Serialisiertes JSON: {}“, json);
}

Im hauptsächlich Funktion, die serde_json Kiste serialisiert die Person Objekt. Der to_string Die Funktion nimmt einen Verweis auf die Person Objekt und gibt einen JSON-String zurück, der die serialisierten Daten darstellt.

Endlich, das hauptsächlich Die Funktion gibt den serialisierten JSON-Code auf der Konsole aus.

Der serde Und serde_json sind vielseitig, Sie können Arrays auch mit serde serialisieren.

verwenden serde::{Serialisieren, Deserialisieren};
verwenden serde_json;
#[ableiten (serialisieren)]
StrukturKoordinaten {
 X: f32,
 y: f32,
}
fnhauptsächlich() {
lassen Punkte = vec![ 
 Koordinaten X: 1.0, y: 2.0 },
 Koordinaten X: 3.5, y: 4.5 },
 ];
lassen json = serde_json:: to_string(&points).expect(„Serialisierung fehlgeschlagen“); 
println!(„Serialisiertes JSON: {}“, json); // Den serialisierten JSON-String drucken
}

Der Punkte Variable ist ein Vektor von Koordinaten Strukturen, die Punkte auf einer Ebene darstellen. Anwenden der Serialisieren Attribut zum Koordinaten Mit struct können Sie den Vektor mühelos in JSON serialisieren.

Darüber hinaus können Sie Aufzählungen mit in JSON serialisieren serde So wie Sie Strukturen und Vektoren serialisieren.

verwenden serde::{Serialisieren, Deserialisieren};
verwenden serde_json;
#[ableiten (serialisieren, deserialisieren)]
AufzählungTier {
 Hund(Zeichenfolge),
 Katze(u32),
 Vogel,
}
fnhauptsächlich() {
lassen Hund = Tier:: Hund("Rostig".to_string());
lassen json = serde_json:: to_string(&dog).expect(„Serialisierung fehlgeschlagen“);
println!(„Serialisiertes JSON: {}“, json);
}

Je nach Variante passt sich der Serialisierungsprozess entsprechend an (in diesem Fall die Tier:: Hund Variante beinhaltet a Zeichenfolge Feld, das Serde als JSON-String serialisiert).

Datendeserialisierung mit Serde

Bei der JSON-Deserialisierung handelt es sich um den Prozess der Umwandlung von JSON-Daten in native Datentypen einer Programmiersprache. Serde bietet ein umfassendes Framework für die JSON-Deserialisierung, das mit den meisten integrierten Datentypen funktioniert.

Ähnlich wie bei der Serialisierung bietet Serde Attribute, mit denen Sie Ihre Rust-Strukturen für den Deserialisierungsprozess mit Anmerkungen versehen können. Zwei häufig verwendete Attribute für die Serialisierung sind #[ableiten (Deserialisieren)] Und #[serde (rename = "json_field_name")] Attribute.

Der #[ableiten (Deserialisieren)] Das Attribut leitet automatisch die Deserialisierungsimplementierung für Sie ab Rust-Strukturtypen, während #[serde (rename = "json_field_name")] Mit dem Attribut können Sie Strukturfelder den entsprechenden JSON-Feldnamen zuordnen.

So können Sie JSON-Daten mit Serde in einen benutzerdefinierten Strukturtyp deserialisieren:

verwenden serde:: Deserialisieren;
verwenden serde_json;
// definiert eine Struktur für Person mit der Deserialize-Eigenschaft von Serde
#[ableiten (Deserialisieren)]
StrukturPerson {
#[serde (umbenennen = "Name")]// benennt das Feld in „name“ um 
 vollständiger Name: Zeichenfolge, 
 Alter: u32,
}
fnhauptsächlich() {
lassen json_data = r#"
 {
"Name": "John Doe",
"Alter": 30
 }
"#;
// deserialisiert die JSON-Daten in eine Person-Struktur 
lassen person: Person = serde_json:: from_str (json_data).unwrap();
// Geben Sie den vollständigen Namen und das Alter der Person aus
println!("Name: {}", person.vollständiger_name);
println!("Alter: {}", Person.Alter);
}

Durch Kommentieren der Person Struktur mit dem #[ableiten (Deserialisieren)] Mit dem Attribut geben Sie an, dass Serde die Struktur aus JSON deserialisieren kann. Der #[serde (rename = "name")] Attribut ordnet das zu Name Feld im JSON zum vollständiger Name Feld.

Der from_str Funktion deserialisiert die json_data Variable in die Person Objekt und das hauptsächlich Die Funktion gibt die Felder auf der Konsole aus.

Serde unterstützt die Deserialisierung verschiedener Rust-Datentypen, einschließlich primitiver Typen, Aufzählungen, verschachtelter Strukturen und Sammlungen.

So können Sie ein JSON-Array in eine Rust-Struktur deserialisieren, die ein Vektorfeld enthält:

verwenden serde:: Deserialisieren;
#[ableiten (Deserialisieren)]
StrukturDaten {
 Zahlen: Vec<u32>,
}
fnhauptsächlich() {
lassen json_data = r#"
 {
„Zahlen“: [1, 2, 3, 4, 5]
 }
"#;
lassen Daten: Data = serde_json:: from_str (json_data).unwrap();
für Nummer In data.numbers {
println!("Nummer: {}", Nummer);
 }
}

Der hauptsächlich Funktion deserialisiert die json_data JSON-Inhalte in die Daten Variable, und die Schleife druckt die Elemente im Vektor.

Sie müssen sicherstellen, dass Sie über die richtigen Datentypen und Bezeichner für einen Deserialisierungsprozess verfügen.

Serde arbeitet mit beliebten Rust-Web-Frameworks zusammen

Serde ist eine leistungsstarke Bibliothek mit vielen Funktionen und einer einfachen API zum Serialisieren und Deserialisieren von Daten in verschiedene Formate.

Serde ist im Rust-Ökosystem weit verbreitet und viele beliebte Crates und Frameworks sind integriert Unterstützung für Serde, einschließlich beliebter Web-Frameworks wie Actix, Warp und Rocket sowie Datenbank-ORMs wie Diesel.