JSON szerializálás és deszerializáció rozsdával

A JSON (JavaScript Object Notation) népszerű adatcsere-formátum lett a szoftverekben fejlesztés egyszerűsége, olvashatósága és a különféle programozások széleskörű támogatása miatt nyelvek. A JSON az XML könnyű alternatívája a szerver és a webalkalmazás vagy a különböző szoftverrendszer-összetevők közötti adatátvitelhez.

A JSON-nal végzett munka egyik kulcsfontosságú szempontja a szerializálás és a deszerializálás folyamata, amely lehetővé teszi, hogy a JSON-adatokat strukturált formátummá alakítsa át, amelyet könnyen kezelhet saját belsejében programokat. A legtöbb esetben, ha más nyelveken szeretne JSON-nal dolgozni, előfordulhat, hogy sorosítania kell a JSON-adatokat a nyelv beépített adatstruktúráiba.

Kezdő lépések a Serdével

A Serde (szerializálás és deszerializáció) egy széles körben használt Rust könyvtár, amely keretet biztosít a konvertáláshoz. Rozsda adatszerkezetek tárolási, átviteli, megosztási és egyéb formátumokba.

A Serde lehetővé teszi a zökkenőmentes konverziót a Rust adattípusok és a különféle adatcsere-formátumok között, beleértve a JSON, YAML, BSON, CBOR, MessagePack és más formátumokat.

A Serde elsődleges célja, hogy a szerializálási és szerializálási folyamatot a lehető legegyszerűbbé és leghatékonyabbá tegye, miközben megőrzi az erős gépelési és biztonsági funkciókat.

Adja hozzá ezeket az irányelveket a függőségek részed Cargo.toml fájlt telepíteni és használni Serde mint a harmadik féltől való függőség a Cargo-tól.

[függőségek]
serde = { verzió = "1.0.159", jellemzők = ["származik"] }
serde_json = "1.0.96"

Mindkettőre szüksége lesz serde és serde_json ládák a JSON-val való interakcióhoz. A serde crate biztosítja az alapvető funkciókat, és a serde_json A crate a Serde speciális megvalósítása a JSON-nal való együttműködéshez.

Így importálhatja a serde_json láda és a Sorozatosítás és Deszerializálni modulok a serde láda:

használat serde::{Serialize, Deserialize};
használat serde_json;

Összességében a Serde egy hatékony eszköz, amelyre szüksége lesz a fejlesztési arzenálban, ha JSON-nal dolgozik a Rustban.

Adatok sorosítása Serdével

A JSON szerializálási folyamat magában foglalja a Rust típus (egyéni vagy beépített) konvertálását JSON-ba más műveletekhez. A Serde attribútumok készletét kínálja, amelyeket a Rust struct-hoz használhat, hogy lehetővé tegye a szerializálási folyamat pontos vezérlését, beleértve a #[derive (Serialize)] attribútum, amely lehetővé teszi, hogy sorosító kódot generáljon az adatstruktúráihoz, és konvertálja a Rust struktúrát JSON-ba.

Tekintsük ezt a struktúrát, amely egy személy bioadatait reprezentálja; így importálhatja és használhatja a Sorozatosítás attribútum a struktúrán:

használat serde::{Serialize, Deserialize};
használat serde_json;
#[derive (Serialize)]
structSzemély {
 név: Húr,
 kor: u32,
}

A megjegyzésekkel ellátva a Személy strukturálja a [#derive (Serialize)], akkor azt mondod a Serde-nek, hogy állítsa elő a szükséges szerializációs kódot a Személy struct automatikusan.

A következőképpen állíthatja be sorozatba a példányt a Személy struct a JSON-ba:

használat serde::{Serialize};
használat serde_json;
fnfő-() {
// a Person struct példány deklarációja a név és az életkor mezőkkel
hagyja személy = személy {
 név: "Chukwuemeriwo".to_string(),
 kor: 28,
 };
// a serde_json könyvtár használatával sorosítja a személyi struktúrát JSON-ba
hagyja json = serde_json:: to_string(&person).expect("A sorozatosítás nem sikerült");
// kiírja a sorosított JSON karakterláncot
println!("Serializált JSON: {}", json);
}

Ban,-ben fő- funkció, a serde_json láda szerializálja a személy tárgy. A to_string függvény hivatkozik a személy objektumot, és egy JSON-karakterláncot ad vissza, amely a sorosított adatokat reprezentálja.

Végül a fő- függvény kinyomtatja a sorosított JSON-t a konzolra.

A serde és serde_json sokoldalúak, a tömböket a serde segítségével is sorosíthatja.

használat serde::{Serialize, Deserialize};
használat serde_json;
#[derive (Serialize)]
structKoordináták {
 x: f32,
 y: f32,
}
fnfő-() {
hagyja pont = vec![ 
 Koordináták { x: 1.0, y: 2.0 },
 Koordináták { x: 3.5, y: 4.5 },
 ];
hagyja json = serde_json:: to_string(&points).expect("A sorozatosítás nem sikerült"); 
println!("Serializált JSON: {}", json); // Nyomtassa ki a sorosított JSON-karakterláncot
}

A pontokat változó egy vektora Koordináták pontokat reprezentáló struktúrák egy síkon. Alkalmazása a Sorozatosítás tulajdonítani a Koordináták A struct lehetővé teszi a vektor JSON-ba való sorba rendezését könnyedén.

Ezenkívül az enumokat JSON-ba sorba rendezheti a következővel serde mint ahogy a struktúrákat és a vektorokat szerializálod.

használat serde::{Serialize, Deserialize};
használat serde_json;
#[derive (szerializálás, sorozatosítás)]
enumÁllat {
 Kutya(Húr),
 Macska(u32),
 Madár,
}
fnfő-() {
hagyja kutya = Állat:: Kutya("Rozsdás".to_string());
hagyja json = serde_json:: to_string(&kutya).expect("A sorozatosítás nem sikerült");
println!("Serializált JSON: {}", json);
}

A változattól függően a sorozatosítási folyamat ennek megfelelően alkalmazkodik (ebben az esetben a Állat:: Kutya változat tartalmazza a Húr mező, amelyet a Serde JSON-karakterláncként szerializál).

Adatok deszerializálása Serdével

A JSON-deszerializálás a JSON-adatok egy programozási nyelv natív adattípusaivá történő átalakításának folyamata. A Serde átfogó keretrendszert biztosít a JSON-deserializáláshoz, amely a legtöbb beépített adattípuson működik.

A szerializáláshoz hasonlóan a Serde attribútumokat kínál, amelyek segítségével megjegyzéseket fűzhet a Rust struktúrákhoz a deszerializálási folyamathoz. A szerializáláshoz két gyakran használt attribútum a #[derive (deserialize)] és #[serde (átnevezés = "json_field_name")] attribútumokat.

A #[derive (deserialize)] attribútum automatikusan levezeti a deserializációs megvalósítást az Ön számára Rozsdaszerkezet típusok, amíg a #[serde (átnevezés = "json_field_name")] Az attribútum lehetővé teszi a struct mezők leképezését a megfelelő JSON mezőnevekre.

A következőképpen deszerializálhatja a JSON-adatokat egyéni struktúratípusokká a Serde segítségével:

használat serde:: Deserialize;
használat serde_json;
// meghatároz egy struktúrát a Serde Deserialize tulajdonsággal rendelkező személy számára
#[derive (deserialize)]
structSzemély {
#[serde (átnevezés = "név")]// átnevezi a mezőt "névre" 
 teljes név: Húr, 
 kor: u32,
}
fnfő-() {
hagyja json_data = r#"
 {
"név": "Gipsz Jakab",
"kor": 30
 }
"#;
// deszerializálja a JSON-adatokat egy személy-struktúrába 
hagyja személy: Személy = serde_json:: from_str (json_data).unwrap();
// Nyomtassa ki a személy teljes nevét és életkorát
println!("Név: {}", személy.teljes_név);
println!("Kor: {}", személy.kor);
}

A megjegyzésekkel ellátva a Személy strukturálja a #[derive (deserialize)] attribútum, jelzi, hogy a Serde deszerializálhatja a struktúrát a JSON-ból. A #[serde (átnevezés = "név")] attribútum leképezi a név mezőben a JSON-ban a teljes név terület.

A from_str függvény deszerializálja a json_data változó a személy objektum, és a fő- függvény kiírja a mezőket a konzolra.

A Serde támogatja a deserializálást különféle Rust adattípusokon, beleértve a primitív típusokat, enumokat, beágyazott struktúrákat és gyűjteményeket.

A következőképpen deszerializálhat egy JSON-tömböt egy vektormezőt tartalmazó Rust-struktúrává:

használat serde:: Deserialize;
#[derive (deserialize)]
structAdat {
 számok: Vec<u32>,
}
fnfő-() {
hagyja json_data = r#"
 {
"számok": [1, 2, 3, 4, 5]
 }
"#;
hagyja data: Data = serde_json:: from_str (json_data).unwrap();
számára szám ban ben data.numbers {
println!("Szám: {}", szám);
 }
}

A fő- függvény deszerializálja a json_data JSON tartalmat a adat változó, és a ciklus kiírja a vektor elemeit.

Gondoskodnia kell arról, hogy a megfelelő adattípusokkal és azonosítókkal rendelkezzen a deszerializációs folyamathoz.

A Serde együttműködik a népszerű Rust webes keretrendszerekkel

A Serde egy hatékony könyvtár számos funkcióval és egy egyszerű API-val az adatok különböző formátumokba történő sorosításához és deszerializálásához.

A Serde széles körben elterjedt a Rust ökoszisztémában, és sok népszerű láda és keretrendszer van beépítve a Serde támogatása, beleértve az olyan népszerű webes keretrendszereket, mint az Actix, a Warp és a Rocket, valamint az adatbázis-ORM-eket Dízel.