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

JSON (нотация объектов JavaScript) стал популярным форматом обмена данными в программном обеспечении. благодаря своей простоте, удобочитаемости и широкой поддержке в различных программах языки. JSON — это облегченная альтернатива XML для передачи данных между сервером и веб-приложением или между различными компонентами программной системы.

Одним из ключевых аспектов работы с JSON является процесс сериализации и десериализации, который позволяет вам преобразовывать данные JSON в структурированный формат, которым вы можете легко манипулировать в своей программы. В большинстве случаев, если вы хотите работать с JSON на других языках, вам может потребоваться сериализовать и десериализовать данные JSON во встроенные структуры данных языка.

Начало работы с Серде

Serde (сериализация и десериализация) — широко используемая библиотека Rust, предоставляющая основу для преобразования Структуры данных Rust в форматы для хранения, передачи, обмена и др.

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

Основное внимание Серде уделяет тому, чтобы сделать процесс сериализации и десериализации максимально простым и эффективным, сохраняя при этом строгие функции типизации и безопасности.

Добавьте эти директивы в зависимости раздел вашего Груз.томл файл для установки и использования Серде как сторонняя зависимость с Cargo.

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

Вам понадобятся оба серде и serde_json ящики для взаимодействия с JSON. серде crate обеспечивает основные функции, а serde_json crate — это конкретная реализация Serde для работы с JSON.

Вот как вы можете импортировать serde_json ящик и сериализовать и Десериализовать модули из серде ящик:

использовать serde::{Сериализация, Десериализация};
использовать serde_json;

В целом, Serde — это мощный инструмент, который вам понадобится в вашем арсенале разработки, если вы работаете с JSON в Rust.

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

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

Рассмотрим эту структуру, представляющую биоданные человека; вот как вы можете импортировать и использовать сериализовать атрибут в структуре:

использовать serde::{Сериализация, Десериализация};
использовать serde_json;
#[получить (сериализовать)]
структураЧеловек {
 имя: Нить,
 возраст: U32,
}

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

Вот как вы можете сериализовать экземпляр Человек структуру в JSON:

использовать серде::{Сериализация};
использовать serde_json;
фносновной() {
// объявление экземпляра структуры Person с полями name и age
позволять человек = человек {
 имя: "Чуквумериво".нанизывать(),
 возраст: 28,
 };
// сериализует структуру человека в JSON, используя библиотеку serde_json
позволять json = serde_json:: to_string(&person).expect("Сериализация не удалась");
// печатает сериализованную строку JSON
распечатать!("Сериализованный JSON: {}", json);
}

в основной функция, serde_json crate сериализует человек объект. нанизывать функция принимает ссылку на человек объект и возвращает строку JSON, представляющую сериализованные данные.

Наконец, основной Функция выводит сериализованный JSON на консоль.

серде и serde_json универсальны, вы также можете сериализовать массивы с помощью serde.

использовать serde::{Сериализация, Десериализация};
использовать serde_json;
#[получить (сериализовать)]
структураКоординаты {
 Икс: ф32,
 у: ф32,
}
фносновной() {
позволять баллы = век![ 
 Координаты { х: 1.0, г: 2.0 },
 Координаты { х: 3.5, г: 4.5 },
 ];
позволять json = serde_json:: to_string(&points).expect("Сериализация не удалась"); 
распечатать!("Сериализованный JSON: {}", json); // Печатаем сериализованную строку JSON
}

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

Кроме того, вы можете сериализовать перечисления в JSON с помощью серде как вы сериализуете структуры и векторы.

использовать serde::{Сериализация, Десериализация};
использовать serde_json;
#[получить (сериализовать, десериализовать)]
перечислениеЖивотное {
 Собака(Нить),
 Кот(U32),
 Птица,
}
фносновной() {
позволять собака = животное:: собака("Ржавый".нанизывать());
позволять json = serde_json:: to_string(&dog).expect("Сериализация не удалась");
распечатать!("Сериализованный JSON: {}", json);
}

В зависимости от варианта процесс сериализации адаптируется соответствующим образом (в этом случае Животное:: Собака вариант включает в себя Нить поле, которое Serde сериализует как строку JSON).

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

Десериализация JSON — это процесс преобразования данных JSON в собственные типы данных языка программирования. Serde предоставляет комплексную платформу для десериализации JSON, которая работает с большинством встроенных типов данных.

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

#[получить (десериализовать)] атрибут автоматически получает реализацию десериализации для вашего Типы структур Rust, в то время #[серде (переименовать = "json_field_name")] Атрибут позволяет сопоставлять поля структуры с соответствующими именами полей JSON.

Вот как вы можете десериализовать данные JSON в пользовательский тип структуры с помощью Serde:

использовать serde:: Десериализовать;
использовать serde_json;
// определяет структуру для Person с трейтом Deserialize от Serde
#[получить (десериализовать)]
структураЧеловек {
#[serde (переименовать = "имя")]// переименовывает поле в "имя" 
 полное имя: Нить, 
 возраст: U32,
}
фносновной() {
позволять json_data = г#"
 {
"имя": "Джон Доу",
"возраст": 30
 }
"#;
// десериализует данные JSON в структуру Person 
позволять человек: Человек = serde_json:: from_str (json_data).unwrap();
// Выводим полное имя и возраст человека
распечатать!("Имя: {}", лицо.ФИО);
распечатать!("Возраст: {}", чел.возраст);
}

Аннотируя Человек структура с #[получить (десериализовать)] атрибут, вы указываете, что Serde может десериализовать структуру из JSON. #[сердце (переименовать = "имя")] атрибут отображает имя поле в JSON для полное имя поле.

from_str функция десериализует json_data переменная в человек объект, и основной функция выводит поля на консоль.

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

Вот как вы можете десериализовать массив JSON в структуру Rust, содержащую векторное поле:

использовать serde:: Десериализовать;
#[получить (десериализовать)]
структураДанные {
 номера: Век<U32>,
}
фносновной() {
позволять json_data = г#"
 {
"числа": [1, 2, 3, 4, 5]
 }
"#;
позволять данные: Данные = serde_json:: from_str (json_data).unwrap();
для число в данные.номера {
распечатать!("Число: {}", число);
 }
}

основной функция десериализует json_data JSON-контент в данные переменная, и цикл печатает элементы вектора.

Вы должны убедиться, что у вас есть правильные типы данных и идентификаторы для процесса десериализации.

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

Serde — это мощная библиотека с множеством функций и простым API для сериализации и десериализации данных в различные форматы.

Serde широко используется в экосистеме Rust, и многие популярные крейты и фреймворки имеют встроенные поддержка Serde, включая популярные веб-фреймворки, такие как Actix, Warp и Rocket, а также ORM баз данных, такие как Дизель.