JSON сериализация и десериализация с Rust

JSON (JavaScript Object Notation) се появи като популярен формат за обмен на данни в софтуера развитие поради своята простота, четливост и широка поддръжка в различни програми езици. JSON е лека алтернатива на XML за предаване на данни между сървър и уеб приложение или между различни компоненти на софтуерната система.

Един от ключовите аспекти на работата с JSON е процесът на сериализация и десериализация, който ви позволява да конвертирате JSON данни в структуриран формат, който можете лесно да манипулирате във вашия програми. Повечето пъти, ако искате да работите с JSON на други езици, може да се наложи да сериализирате и десериализирате JSON данните във вградените структури от данни на езика.

Първи стъпки със Serde

Serde (сериализация и десериализация) е широко използвана библиотека на Rust, която предоставя рамка за конвертиране Структури от данни на Rust във формати за съхранение, предаване, споделяне и други.

Serde позволява безпроблемно преобразуване между типове данни на Rust и различни формати за обмен на данни, включително JSON, YAML, BSON, CBOR, MessagePack и други.

Основният фокус на Serde е да направи процеса на сериализация и десериализация възможно най-прост и ефективен, като същевременно поддържа силни функции за въвеждане и безопасност.

Добавете тези директиви към зависимости раздел от вашия Cargo.toml файл за инсталиране и използване Серде като зависимост от трета страна с Cargo.

[зависимости]
сърде = { версия = "1.0.159", функции = ["извличам"] }
serde_json = "1.0.96"

Ще ви трябват и двете сърде и serde_json каси за взаимодействие с JSON. The сърде crate осигурява основните функционалности и serde_json crate е специфична реализация на Serde за работа с JSON.

Ето как можете да импортирате serde_json щайга и Сериализиране и Десериализиране модули от сърде щайга:

използване serde::{Сериализиране, Десериализиране};
използване serde_json;

Като цяло Serde е мощен инструмент, от който ще имате нужда в арсенала си за разработка, ако работите с JSON в Rust.

Сериализация на данни със Serde

Процесът на сериализиране на JSON включва конвертиране на тип Rust (персонализиран или вграден) в JSON за други операции. Serde предоставя набор от атрибути, които можете да използвате с Rust struct, за да активирате прецизен контрол върху процеса на сериализация, включително #[производство (сериализиране)] атрибут, който ви позволява да генерирате сериализиращ код за вашите структури от данни и да конвертирате вашата Rust структура в JSON.

Помислете за тази структура, представляваща биоданните на дадено лице; ето как можете да импортирате и използвате Сериализиране атрибут на структурата:

използване serde::{Сериализиране, Десериализиране};
използване serde_json;
#[производство (сериализиране)]
структураЛице {
 име: низ,
 възраст: u32,
}

Чрез анотиране на Лице структура с [#derive (сериализиране)], вие казвате на Serde да генерира необходимия сериализиращ код за Лице структурирайте автоматично.

Ето как можете да сериализирате екземпляр на Лице структура към JSON:

използване serde::{Serialize};
използване serde_json;
fnосновен() {
// декларация на екземпляра на структурата Person с полетата за име и възраст
позволявам човек = Лице {
 име: "Chukwuemeriwo".to_string(),
 възраст: 28,
 };
// сериализира структурата person в JSON, използвайки библиотеката serde_json
позволявам json = serde_json:: to_string(&person).expect(„Неуспешно сериализиране“);
// отпечатва сериализирания JSON низ
println!(„Сериализиран JSON: {}“, json);
}

В основен функция, на serde_json щайгата сериализира човек обект. The към_низ функцията взема препратка към човек обект и връща JSON низ, представляващ сериализираните данни.

И накрая, на основен функцията отпечатва сериализирания JSON на конзолата.

The сърде и serde_json са универсални, можете също да сериализирате масиви със serde.

използване serde::{Сериализиране, Десериализиране};
използване serde_json;
#[производство (сериализиране)]
структураКоординати {
 х: f32,
 y: f32,
}
fnосновен() {
позволявам точки = vec![ 
 Координати { x: 1.0, y: 2.0 },
 Координати { x: 3.5, y: 4.5 },
 ];
позволявам json = serde_json:: to_string(&points).expect(„Неуспешно сериализиране“); 
println!(„Сериализиран JSON: {}“, json); // Отпечатване на сериализирания JSON низ
}

The точки променливата е вектор на Координати структури, представляващи точки в равнина. Прилагане на Сериализиране атрибут на Координати struct ви позволява да сериализирате вектора в JSON без усилие.

Освен това можете да сериализирате enum в JSON с сърде като сериализирате структури и вектори.

използване serde::{Сериализиране, Десериализиране};
използване serde_json;
#[производство (сериализиране, десериализиране)]
изброяванеЖивотно {
 куче(низ),
 котка(u32),
 птица,
}
fnосновен() {
позволявам куче = Животно:: Куче ("Ръсти".to_string());
позволявам json = serde_json:: to_string(&dog).expect(„Неуспешно сериализиране“);
println!(„Сериализиран JSON: {}“, json);
}

В зависимост от варианта, процесът на сериализация се адаптира съответно (в този случай, the Животно:: Куче вариантът включва a низ поле, което Serde ще сериализира като JSON низ).

Десериализация на данни със Serde

Десериализацията на JSON е процес на трансформиране на JSON данни в собствени типове данни на език за програмиране. Serde предоставя цялостна рамка за JSON десериализация, която работи с повечето вградени типове данни.

Подобно на сериализацията, Serde предлага атрибути, които можете да използвате, за да коментирате вашите Rust структури за процеса на десериализация. Два често използвани атрибута за сериализация са #[производство (десериализиране)] и #[серде (преименуване = "json_field_name")] атрибути.

The #[производство (десериализиране)] атрибут автоматично извлича внедряването на десериализация за вашия Типове структури на Rust, докато #[серде (преименуване = "json_field_name")] атрибут ви позволява да картографирате структурни полета към съответните имена на JSON полета.

Ето как можете да десериализирате JSON данни в персонализиран тип структура със Serde:

използване serde:: Десериализиране;
използване serde_json;
// дефинира структура за Person с характеристиката Deserialize от Serde
#[производство (десериализиране)]
структураЛице {
#[serde (преименуване = "име")]// преименува полето на "име" 
 пълно име: низ, 
 възраст: u32,
}
fnосновен() {
позволявам json_data = r#"
 {
"име": "Джон Доу",
"възраст": 30
 }
"#;
// десериализира JSON данните в структура Person 
позволявам човек: Лице = serde_json:: from_str (json_data).unwrap();
// Отпечатайте пълното име и възрастта на лицето
println!(„Име: {}“, лице.пълно_име);
println!(„Възраст: {}“, person.age);
}

Чрез анотиране на Лице структура с #[производство (десериализиране)] атрибут, вие посочвате, че Serde може да десериализира структурата от JSON. The #[serde (преименуване = "име")] атрибут картографира име поле в JSON към пълно име поле.

The от_ул функцията десериализира json_данни променлива в човек обект, и основен функцията отпечатва полетата на конзолата.

Serde поддържа десериализация на различни типове данни на Rust, включително примитивни типове, enum, вложени структури и колекции.

Ето как можете да десериализирате JSON масив в структура на Rust, съдържаща векторно поле:

използване serde:: Десериализиране;
#[производство (десериализиране)]
структураДанни {
 числа: Vec<u32>,
}
fnосновен() {
позволявам json_data = r#"
 {
"числа": [1, 2, 3, 4, 5]
 }
"#;
позволявам данни: Данни = serde_json:: from_str (json_data).unwrap();
за номер в data.numbers {
println!(„Номер: {}“, номер);
 }
}

The основен функцията десериализира json_данни JSON съдържание в данни променлива и цикълът отпечатва елементите във вектора.

Трябва да се уверите, че имате правилните типове данни и идентификатори за процес на десериализация.

Serde взаимодейства с популярни уеб рамки Rust

Serde е мощна библиотека с много функции и прост API за сериализиране и десериализиране на данни в различни формати.

Serde е широко възприет в екосистемата на Rust и много популярни каси и рамки имат вградени поддръжка за Serde, включително популярни уеб рамки като Actix, Warp и Rocket и бази данни ORM като дизел.