Serializacja JSON i deserializacja z Rust

JSON (JavaScript Object Notation) stał się popularnym formatem wymiany danych w oprogramowaniu rozwoju ze względu na jego prostotę, czytelność i szerokie wsparcie w różnych programach Języki. JSON to lekka alternatywa dla XML do przesyłania danych między serwerem a aplikacją internetową lub między różnymi składnikami systemu oprogramowania.

Jednym z kluczowych aspektów pracy z JSON jest proces serializacji i deserializacji, który umożliwia konwersję danych JSON do formatu strukturalnego, którym można łatwo manipulować w swoim programy. W większości przypadków, jeśli chcesz pracować z JSON w innych językach, może być konieczne serializowanie i deserializacja danych JSON do wbudowanych struktur danych języka.

Pierwsze kroki z Serde

Serde (serializacja i deserializacja) to szeroko stosowana biblioteka Rust, która zapewnia ramy do konwersji Rdzawe struktury danych na formaty do przechowywania, transmisji, udostępniania i inne.

Serde umożliwia bezproblemową konwersję między typami danych Rust i różnymi formatami wymiany danych, w tym JSON, YAML, BSON, CBOR, MessagePack i innymi.

Głównym celem Serde jest uczynienie procesu serializacji i deserializacji tak prostym i wydajnym, jak to tylko możliwe, przy jednoczesnym zachowaniu silnych funkcji pisania i bezpieczeństwa.

Dodaj te dyrektywy do pliku zależności sekcja twojego Cargo.toml plik do zainstalowania i używania Serde jak zależność od strony trzeciej z Cargo.

[zależności]
serdeczny = { wersja = "1.0.159", funkcje = ["czerpać"] }
serde_json = "1.0.96"

Będziesz potrzebować obu serdeczny I serde_json skrzynie do interakcji z JSON. The serdeczny crate zapewnia podstawowe funkcje, a serde_json crate to specyficzna implementacja Serde do pracy z JSON.

Oto jak możesz zaimportować plik serde_json skrzynia i serializować I Deserializuj moduły z serdeczny skrzynia:

używać serde::{Serialize, Deserialize};
używać serde_json;

Ogólnie rzecz biorąc, Serde to potężne narzędzie, którego będziesz potrzebować w swoim arsenale programistycznym, jeśli pracujesz z JSON w Rust.

Serializacja danych za pomocą Serde

Proces serializacji JSON obejmuje konwersję typu Rust (niestandardowego lub wbudowanego) na JSON dla innych operacji. Serde udostępnia zestaw atrybutów, których możesz użyć ze strukturą Rust, aby umożliwić precyzyjną kontrolę nad procesem serializacji, w tym #[pochodna (serializacja)] atrybut, który pozwala wygenerować kod serializacji dla struktur danych i przekonwertować strukturę Rusta na JSON.

Rozważ tę strukturę reprezentującą dane biologiczne osoby; Oto jak możesz importować i używać plików serializować atrybut na strukturze:

używać serde::{Serialize, Deserialize};
używać serde_json;
#[pochodna (serializacja)]
strukturaOsoba {
 nazwa: Strunowy,
 wiek: u32,
}

Dokonując adnotacji dot Osoba konstrukcja z [#pochodna (Serializacja)], mówisz Serde, aby wygenerował niezbędny kod serializacji dla Osoba konstruować automatycznie.

Oto, w jaki sposób można serializować instancję programu Osoba struktura do JSON:

używać serde::{Serialize};
używać serde_json;
przypgłówny() {
// deklaracja instancji struktury Person z polami nazwa i wiek
pozwalać osoba = osoba {
 nazwa: „Chukwuemeriwo”.to_string(),
 wiek: 28,
 };
// serializuje strukturę osoby do formatu JSON przy użyciu biblioteki serde_json
pozwalać json = serde_json:: to_string(&person).expect(„Serializacja nie powiodła się”);
// drukuje serializowany łańcuch JSON
drukuj!(„Serializowany kod JSON: {}”, json);
}

w główny funkcja, tzw serde_json skrzynia serializuje osoba obiekt. The do_ciągu funkcja przyjmuje odniesienie do osoba obiekt i zwraca ciąg JSON reprezentujący serializowane dane.

Wreszcie, główny funkcja drukuje serializowany JSON do konsoli.

The serdeczny I serde_json są wszechstronne, możesz także serializować tablice za pomocą serde.

używać serde::{Serialize, Deserialize};
używać serde_json;
#[pochodna (serializacja)]
strukturaWspółrzędne {
 X: f32,
 y: f32,
}
przypgłówny() {
pozwalać punkty = vec![ 
 Współrzędne X: 1.0, y: 2.0 },
 Współrzędne X: 3.5, y: 4.5 },
 ];
pozwalać json = serde_json:: to_string(&points).expect(„Serializacja nie powiodła się”); 
drukuj!(„Serializowany kod JSON: {}”, json); // Wydrukuj serializowany łańcuch JSON
}

The zwrotnica zmienna jest wektorem Współrzędne struktury reprezentujące punkty na płaszczyźnie. Stosowanie serializować atrybut do Współrzędne struct umożliwia bezproblemową serializację wektora do formatu JSON.

Dodatkowo możesz serializować wyliczenia do JSON za pomocą serdeczny tak jak serializujesz struktury i wektory.

używać serde::{Serialize, Deserialize};
używać serde_json;
#[pochodna (serializacja, deserializacja)]
wyliczenieZwierzę {
 Pies(Strunowy),
 Kot(u32),
 Ptak,
}
przypgłówny() {
pozwalać pies = Zwierzę:: Pies("Zardzewiały".to_string());
pozwalać json = serde_json:: to_string(&dog).expect(„Serializacja nie powiodła się”);
drukuj!(„Serializowany kod JSON: {}”, json);
}

W zależności od wariantu proces serializacji odpowiednio się dostosowuje (w tym przypadku Zwierzę:: Pies wariant zawiera a Strunowy pole, które Serde serializuje jako ciąg JSON).

Deserializacja danych za pomocą Serde

Deserializacja JSON to proces przekształcania danych JSON w natywne typy danych języka programowania. Serde zapewnia kompleksową platformę deserializacji JSON, która działa na większości wbudowanych typów danych.

Podobnie jak serializacja, Serde oferuje atrybuty, których można użyć do opisywania struktur Rusta w procesie deserializacji. Dwa powszechnie używane atrybuty do serializacji to #[wyprowadź (deserializuj)] I #[serde (rename = "json_field_name")] atrybuty.

The #[wyprowadź (deserializuj)] atrybut automatycznie wyprowadza implementację deserializacji dla twojego Typy struktur rdzy, podczas #[serde (rename = "json_field_name")] atrybut umożliwia mapowanie pól struktury na odpowiadające im nazwy pól JSON.

Oto jak możesz deserializować dane JSON do niestandardowego typu struktury za pomocą Serde:

używać serde:: Deserializacja;
używać serde_json;
// definiuje strukturę dla osoby z cechą deserializacji z Serde
#[wyprowadź (deserializuj)]
strukturaOsoba {
#[serde (zmień nazwę = "nazwa")]// zmienia nazwę pola na „nazwa” 
 pełna_nazwa: Strunowy, 
 wiek: u32,
}
przypgłówny() {
pozwalać json_data = r#"
 {
"nazwa": "Nieznany z nazwiska",
"wiek": 30
 }
"#;
// deserializuje dane JSON do struktury Person 
pozwalać osoba: Osoba = serde_json:: from_str (json_data).unwrap();
// Wydrukuj pełne imię i nazwisko oraz wiek osoby
drukuj!("Nazwa: {}", osoba.pełne_nazwisko);
drukuj!("Wiek: {}", osoba.wiek);
}

Dokonując adnotacji dot Osoba konstrukcja z #[wyprowadź (deserializuj)] atrybut, wskazujesz, że Serde może deserializować strukturę z JSON. The #[serde (rename = "name")] atrybut odwzorowuje nazwa pole w JSON do imię i nazwisko pole.

The z_str funkcja deserializuje json_data zmienna w osoba obiekt i główny funkcja drukuje pola do konsoli.

Serde obsługuje deserializację różnych typów danych Rust, w tym typów pierwotnych, wyliczeniowych, zagnieżdżonych struktur i kolekcji.

Oto jak można deserializować tablicę JSON do struktury Rust zawierającej pole wektorowe:

używać serde:: Deserializacja;
#[wyprowadź (deserializuj)]
strukturaDane {
 liczby: Vec<u32>,
}
przypgłówny() {
pozwalać json_data = r#"
 {
"liczby": [1, 2, 3, 4, 5]
 }
"#;
pozwalać dane: Dane = serde_json:: from_str (json_data).unwrap();
Do numer W dane.liczby {
drukuj!(„Liczba: {}”, liczba);
 }
}

The główny funkcja deserializuje json_data zawartość JSON do dane zmienna, a pętla drukuje elementy w wektorze.

Musisz upewnić się, że masz odpowiednie typy danych i identyfikatory dla procesu deserializacji.

Serde współpracuje z popularnymi frameworkami sieciowymi Rust

Serde to potężna biblioteka z wieloma funkcjami i prostym interfejsem API do serializacji i deserializacji danych do różnych formatów.

Serde jest szeroko stosowany w ekosystemie Rust, a wiele popularnych skrzynek i frameworków ma wbudowane obsługa Serde, w tym popularnych frameworków internetowych, takich jak Actix, Warp i Rocket, oraz ORM baz danych, takich jak Diesel.