Работа с JSON в C#: сериализация и десериализация объектов
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
Формат JSON, в настоящее время, один из наиболее часто используемых текстовых форматов данных, используемых как для хранения информации об объектах, так и для обмена этой информацией по Сети. В свою очередь, сериализация JSON — это очень важный момент при разработке различных веб-приложений. И сегодня мы рассмотрим один из вариантов сериализации/десериализации объектов C# с использованием классов и объектов, расположенных в пространстве имен System.Text.Json . Этот сериализатор с момента выхода .NET Core 3 претерпел значительные изменения и показывает достаточно хорошие результаты тестов.
Что такое «сериализация»?
В соответствии с определением, данным Microsoft, сериализация — это процесс преобразования объекта в поток байтов для сохранения или передачи в память, базу данных или файл. Сериализация используется для того, чтобы сохранить состояния объекта для последующего воссоздания при необходимости. Обратный процесс называется десериализацией.
Например, при разработке приложений в Visual Studio, активно используются файлы в формате JSON, позволяющие сохранять настройки вашего приложения и восстанавливать эти настройки при запуске. Например, в C# вы можете сохранить (сериализовать) положение и размер главного окна приложения и при повторном запуске приложения восстановить (десериализовать) эти настройки объекта (главного окна приложения).
Для сериализации/десериализации JSON в C# можно использовать как штатный сериализатор JsonSerializer , расположенный в пространстве имен System.Text.Json , так и решения сторонних разработчиков, например, часто используемый JSON.NET. Мы будем использовать штатный сериализатор.
Пример сериализации и десериализации JSON
Допустим, у нас имеется вот такой класс для хранения информации о человеке:
public class Person < public string Name < get; set; >public string Surname < get; set; >private int age; public int Age < get =>age; set < if ((value < 0) || (value >100)) throw new Exception("Возраст должен находится в интервале от 0 до 100 лет"); else age = value; > > public DateTime Birthday < get; set; >>
Создадим объект этого класса и сохраним состояние объекта в файл в формате JSON:
Person person = new Person() < Name = "Вася", Surname = "Пупкин", Age = 38, Birthday = new DateTime(1983, 01, 16) >; string personJson = JsonSerializer.Serialize(person, typeof(Person)); StreamWriter file = File.CreateText("person.json"); file.WriteLine(personJson); file.Close();
Здесь мы выполнили следующие действия:
- Создали сам объект для сериализации ( person )
- Сериализовали объект в строку ( string ) используя сериализатор JsonSerializer
- Записали полученную строку в текстовый файл person.json .
Теперь рядом с exe-файлом приложения появился файл со следующим содержимым:
Теперь мы можем при следующем запуске программы восстановить (десериализовать) этот объект в нашей программе, например, так:
if (File.Exists("person.json")) < string data = File.ReadAllText("person.json"); Person person = JsonSerializer.Deserialize(data); Console.WriteLine($"Имя: "); Console.WriteLine($"Фамилия: "); Console.WriteLine($"Возраст: "); Console.WriteLine($"День рождения: "); >
Имя: Вася
Фамилия: Пупкин
Возраст: 38
День рождения: 16.01.1983 0:00:00
Настройки сериализации JSON
Настройка сериализации с помощью JsonSerializerOptions
Для настройки сериализации мы можем передать в метод Serialize второй параметр — объект класса JsonSerializerOptions , который содержит настройки сериализации/десериализации объектов. Основные свойства этого класса следующие:
- bool AllowTrailingCommas — устанавливает, надо ли добавлять после последнего элемента в json запятую. Если равно true , запятая добавляется
- JsonNamingPolicy DictionaryKeyPolicy — возвращает или задает политику, используемую для преобразования имени ключа IDictionary в другой формат, например CamelCase.
- JavaScriptEncoder Encoder — Возвращает или устанавливает кодировщик, используемый при экранировании строк. Укажите значение null для использования кодировщика по умолчанию
- bool IgnoreNullValues — устанавливает, будут ли сериализоваться/десериализоваться в json объекты и их свойства со значением null
- bool IgnoreReadOnlyProperties — аналогично устанавливает, будут ли сериализоваться свойства, предназначенные только для чтения
- int MaxDepth — возвращает или задает максимальную глубину, разрешенную при сериализации или десериализации JSON, при этом значение по умолчанию 0 указывает максимальную глубину 64 .
- bool PropertyNameCaseInsensitive — возвращает или задает значение, которое определяет, использует ли имя свойства сравнение без учета регистра во время десериализации. Значение по умолчанию — false .
- JsonNamingPolicy PropertyNamingPolicy — возвращает или задает значение, указывающее политику, используемую для преобразования имени свойства объекта в другой формат, например CamelCase стиль, или null , чтобы оставить имена свойств без изменений.
- JsonCommentHandling ReadCommentHandling — Возвращает или задает значение, определяющее, как комментарии обрабатываются во время десериализации
- bool WriteIndented — устанавливает, будут ли добавляться в json пробелы (условно говоря, для красоты). Если равно true устанавливаются дополнительные пробелы
Рассмотрим несколько примеров использования этих настроек сериализации Json.
Как получить форматированную строку (с лидирующими пробелами) Json?
Для этого необходимо в настройках сериализации указать значение WriteIndented = true :
Person person = new Person() < Name = "Вася", Surname = "Пупкин", Age = 38, Birthday = new DateTime(1983, 01, 16) >; JsonSerializerOptions options = new JsonSerializerOptions() < WriteIndented = true >; string personJson = JsonSerializer.Serialize(person, options); Console.WriteLine(personJson);
<
«Name»: «\u0412\u0430\u0441\u044F»,
«Surname»: «\u041F\u0443\u043F\u043A\u0438\u043D»,
«Age»: 38,
«Birthday»: «1983-01-16T00:00:00»
>
Как запретить экранировать строки при сериализации JSON?
В примере выше у нас все строки (имя, фамилия) экранированы. С точки зрения безопасности — это полностью правильное решение, но не всегда удобно для чтения. Чтобы позволить сериализатору не экранировать символы в строках мы можем воспользоваться свойством Encoder у JsonSerializerOptions следующим образом:
using System.Text.Encodings.Web; JsonSerializerOptions options = new JsonSerializerOptions() < WriteIndented = true, //добавляем пробелы для красоты Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping //не экранируем символы в строках >;
в этом случае, объект из примера выше будет выглядеть следующим образом:
<
«Name»: «Вася»,
«Surname»: «Пупкин»,
«Age»: 38,
«Birthday»: «1983-01-16T00:00:00»
>
Как сериализовать имена свойств в CamelCase?
По умолчанию, сериализация имен свойств объекта проводится как есть, однако, если вам необходимо применить к именам свойств стиль CamelCase (он же «верблюжий»), то можно использовать следующую настройку сериализации:
using System.Text.Encodings.Web; JsonSerializerOptions options = new JsonSerializerOptions() < . PropertyNamingPolicy = JsonNamingPolicy.CamelCase //используем стиль CamekCase >;
Теперь наш объект в JSON будет выглядеть следующим образом:
<
«name»: «Вася»,
«surname»: «Пупкин»,
«age»: 38,
«birthday»: «1983-01-16T00:00:00»
>
Настройка сериализации с помощью атрибутов
При сериализации/десериализации объектов в JSON бывает необходимым исключить какое-либо свойство из строки JSON. Например, в нашем объекте Person таким свойством может быть свойство Age , так как мы можем легко рассчитать возраст человека, зная его день рождения и каждый раз «таскать» это свойство в JSON — смысла нет. В этом случае нам может пригодиться настройка сериализации JSON с использованием атрибутов. Для того, чтобы воспользоваться таким видом настройки, необходимо подключить пространство имен System.Text.Json.Serialization .
Исключим свойство Age из сериализуемых, используя атрибут JsonIgnore :
public class Person < public string Name < get; set; >public string Surname < get; set; >private int age; [JsonIgnore] public int Age //теперь свойство Age не будет сериализоваться < get =>age; set < if ((value < 0) || (value >100)) throw new Exception("Возраст должен находится в интервале от 0 до 100 лет"); else age = value; > > public DateTime Birthday < get; set; >>
Также, часто используемым атрибутом для настройки сериализации/десериализации JSON является атрибут JsonPropertyName , который позволяет задать произвольное имя сериализуемому свойству. Например,
public class Person < [JsonPropertyName("PersonFamily")] public string Surname < get; set; >>
Теперь свойство Surname будет сериализоваться в JSON с именем PersonFamily .
Особенности сериализации и десериализации JSON
При сериализации/десериализации JSON с использованием штатного сериализатора JsonSerializer необходимо обратить внимание на следующие моменты:
Десериализуемый объект должен иметь конструктор без параметров
Например, во всех примерах по работе с JSON в C# мы использовали конструктор по умолчанию. Если бы наш класс имел, например, только вот такой конструктор:
public class Person < public string Name < get; set; >. public Person(string name) < Name = name; >>
То при попытке десериализовать такой объект мы получим исключение:
System.NotSupportedException: «Deserialization of reference types without parameterless constructor is not supported. Type ‘CSharpJson.Person’»
Сериализации подлежат только публичные свойства
Все непубличные свойства, а также поля сериализуемого класса игнорируются сериализатором.
Итого
Сегодня мы рассмотрели основные моменты того, как в C# происходит сериализация и десериализация объектов в JSON. Научились использовать настройки сериализации и десериализации с использованием атрибутов и специального класса JsonSerializerOptions . Конечно, возможности работы с JSON в C# этим не ограничиваются, но полученных знаний нам будет пока достаточно, чтобы попробовать использовать JSON в своих приложениях.
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
Работа с JSON
JSON (JavaScript Object Notation) является одним из наиболее популярных форматов для хранения и передачи данных. И платформа .NET предоставляет функционал для работы с JSON.
Основная функциональность по работе с JSON сосредоточена в пространстве имен System.Text.Json . Ключевым типом является класс JsonSerializer , который и позволяет сериализовать объект в json и, наоборот, десериализовать код json в объект C#.
Для сохранения объекта в json в классе JsonSerializer определен статический метод Serialize() и его асинхронный двойник SerializeAsyc() , которые имеют ряд перегруженных версий. Некоторые из них:
- string Serialize(Object obj, Type type, JsonSerializerOptions options) : сериализует объект obj типа type и возвращает код json в виде строки. Последний необязательный параметр options позволяет задать дополнительные опции сериализации
- string Serialize(T obj, JsonSerializerOptions options) : типизированная версия сериализует объект obj типа T и возвращает код json в виде строки.
- Task SerializeAsync(Stream utf8Json, Object obj, Type type, JsonSerializerOptions options) : сериализует объект obj типа type и записывает его в поток utf8Json. Последний необязательный параметр options позволяет задать дополнительные опции сериализации
- Task SerializeAsync(Stream utf8Json, T obj, JsonSerializerOptions options) : типизированная версия сериализует объект obj типа T в поток utf8Json.
Для десериализации кода json в объект C# применяется метод Deserialize() и его асинхронный двойник DeserializeAsync() , которые имеют различные версии. Некоторые из них:
- object? Deserialize(string json, Type type, JsonSerializerOptions options) : десериализует строку json в объект типа type и возвращает десериализованный объект. Последний необязательный параметр options позволяет задать дополнительные опции десериализации
- T? Deserialize(string json, JsonSerializerOptions options) : десериализует строку json в объект типа T и возвращает его.
- ValueTask DeserializeAsync(Stream utf8Json, Type type, JsonSerializerOptions options, CancellationToken token) : десериализует данные из потока utf8Json, который представляет объект JSON, в объект типа type. Последние два параметра необязательны: options позволяет задать дополнительные опции десериализации, а token устанавливает CancellationToken для отмены задачи. Возвращается десериализованный объект, обернутый в ValueTask
- ValueTask DeserializeAsync(Stream utf8Json, JsonSerializerOptions options, CancellationToken token) : десериализует данные из потока utf8Json, который представляет объект JSON, в объект типа T. Возвращается десериализованный объект, обернутый в ValueTask
Рассмотрим применение класса на простом примере. Сериализуем и десериализуем простейший объект:
using System.Text.Json; Person tom = new Person("Tom", 37); string json = JsonSerializer.Serialize(tom); Console.WriteLine(json); Person? restoredPerson = JsonSerializer.Deserialize(json); Console.WriteLine(restoredPerson?.Name); // Tom class Person < public string Name < get;>public int Age < get; set; >public Person(string name, int age) < Name = name; Age = age; >>
Здесь вначале сериализуем с помощью метода JsonSerializer.Serialize() объект типа Person в стоку с кодом json. Затем обратно получаем из этой строки объект Person посредством метода JsonSerializer.Deserialize() .
Хотя в примере выше сериализовался/десериализовался объект класса, но подобным способом мы также можем сериализовать/десериализовать структуры.
Некоторые замечания по сериализации/десериализации
Объект, который подвергается десериализации, должен иметь либо конструктор без параметров, либо конструктор, для всех параметров которого в десериализуемом json-объекте есть значения (соответствие между параметрами конструктора и свойствами json-объекта устанавливается на основе названий, причем регистр не играет значения).
Сериализации подлежат только публичные свойства объекта (с модификатором public).
Запись и чтение файла json
Поскольку методы SerializeAsyc/DeserializeAsync могут принимать поток типа Stream, то соответственно мы можем использовать файловый поток для сохранения и последующего извлечения данных:
using System.Text.Json; // сохранение данных using (FileStream fs = new FileStream("user.json", FileMode.OpenOrCreate)) < Person tom = new Person("Tom", 37); await JsonSerializer.SerializeAsync(fs, tom); Console.WriteLine("Data has been saved to file"); > // чтение данных using (FileStream fs = new FileStream("user.json", FileMode.OpenOrCreate)) < Person? person = await JsonSerializer.DeserializeAsync(fs); Console.WriteLine($"Name: Age: "); > class Person < public string Name < get;>public int Age < get; set; >public Person(string name, int age) < Name = name; Age = age; >>
В данном случае вначале данные сохраняются в файл user.json и затем считываются из него.
Настройка сериализации с помощью JsonSerializerOptions
По умолчанию JsonSerializer сериализует объекты в минимифицированный код. С помощью дополнительного параметра типа JsonSerializerOptions можно настроить механизм сериализации/десериализации, используя свойства JsonSerializerOptions. Некоторые из его свойств:
- AllowTrailingCommas : устанавливает, надо ли добавлять после последнего элемента в json запятую. Если равно true , запятая добавляется
- DefaultIgnoreCondition : устанавливает, будут ли сериализоваться/десериализоваться в json свойства со значениями по умолчанию
- IgnoreReadOnlyProperties : аналогично устанавливает, будут ли сериализоваться свойства, предназначенные только для чтения
- WriteIndented : устанавливает, будут ли добавляться в json пробелы (условно говоря, для красоты). Если равно true устанавливаются дополнительные пробелы
using System.Text.Json; Person tom = new Person("Tom", 37); var options = new JsonSerializerOptions < WriteIndented = true >; string json = JsonSerializer.Serialize(tom, options); Console.WriteLine(json); Person? restoredPerson = JsonSerializer.Deserialize(json); Console.WriteLine(restoredPerson?.Name);
Настройка сериализации с помощью атрибутов
По умолчанию сериализации подлежат все публичные свойства. Кроме того, в выходном объекте json все названия свойств соответствуют названиям свойств объекта C#. Однако с помощью атрибутов JsonIgnore и JsonPropertyName .
Атрибут JsonIgnore позволяет исключить из сериализации определенное свойство. А JsonPropertyName позволяет замещать оригинальное название свойства. Пример использования:
using System.Text.Json; using System.Text.Json.Serialization; Person tom = new Person("Tom", 37); string json = JsonSerializer.Serialize(tom); Console.WriteLine(json); Person? person = JsonSerializer.Deserialize(json); Console.WriteLine($"Name: Age: "); class Person < [JsonPropertyName("firstname")] public string Name < get;>[JsonIgnore] public int Age < get; set; >public Person(string name, int age) < Name = name; Age = age; >>
В данном случае свойство Age будет игнорироваться, а для свойства Name будет использоваться псевдоним «firstname». Консольный вывод:
Name: Tom Age: 0
Обратите внимание, что, поскольку свойство Age не было сериализовано, то при десериализации для него используется значение по умолчанию.
Как десериализовать json в объекты в C#? [дубликат]
Имеется строка в вида: <"test":true,"list":[<"a":"aa","b":"bb">,,,]> Как мне ее Deserialize в объекты? Известно, что test — string значение, list — коллекция объектов. Данный обобьет доступен для проекта. Но не могу получить сначала коллекцию объектов, потом string значение.
Отслеживать
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков
задан 7 мая 2019 в 3:16
161 10 10 бронзовых знаков
Постарайтесь писать более развёрнутые вопросы. Для получения ответа поясните, в чём именно вы видите проблему, как её воспроизвести, что вы хотите получить в результате и т. д. Приведите пример кода, который вы написали.
7 мая 2019 в 4:01
@tym32167 это не ассоциативный массив в общем-то, это ещё более просто.
7 мая 2019 в 6:28
@AK ну, тогда дубликат вот этого
7 мая 2019 в 6:45
2 ответа 2
Сортировка: Сброс на вариант по умолчанию
Используйте newtonsoft json
string json = @"< 'Email': '[email protected]', 'Active': true, 'CreatedDate': '2013-01-20T00:00:00Z', 'Roles': [ 'User', 'Admin' ] >"; Account account = JsonConvert.DeserializeObject(json); Console.WriteLine(account.Email); // [email protected] Отслеживать
28.6k 19 19 золотых знаков 58 58 серебряных знаков 136 136 бронзовых знаков
ответ дан 7 мая 2019 в 4:45
QuaternioNoir QuaternioNoir
1,284 7 7 серебряных знаков 16 16 бронзовых знаков
Всё это конечно неплохо и в правильном направлении — но вообще-то не показано самое главное: классы для десериализации (у вас — Account), да и показать лучше на тех же входных данных, что и у автора.
7 мая 2019 в 6:30
Но не могу получить сначала коллекцию объектов, потом string значение.
Вот классы для десериализации:
public partial class Data < [JsonProperty("test")] public bool Test < get; set; >[JsonProperty("list")] public List[] List < get; set; >> public partial class List < [JsonProperty("a")] public string A < get; set; >[JsonProperty("b")] public string B < get; set; >> А вот сама десериализация:
var source = "<\"test\":true,\"list\":[<\"a\":\"aa\",\"b\":\"bb\">,,,]>"; var result = JsonConvert.DeserializeObject(source); Сериализация данных в JSON — Веб-разработка на Go
В вебе взаимодействие происходит по схеме клиент-сервер. Клиент отправляет запрос, а сервер отдает ответ.
Обычно в запросах и ответах содержится информация о том, что именно клиент хочет от сервера. Например, при запросах на получение данных указывается, какие данные сервер должен вернуть. Чаще всего эти данные представляются в виде структур, при этом нам нужно передать их в текстовом виде. В этом случае разработчики используют сериализацию.
В этом уроке мы разберем формат сериализации данных — JSON. Мы рассмотрим, как сериализовать и десериализовать данные в JSON в Golang.
Сериализация и десериализация в Golang
Представим, что нам нужно получить список пользователей. Клиент отправляет запрос GET /users , а сервер отдает ответ в виде списка пользователей. Список пользователей — это массив структур. Каждая структура содержит информацию о пользователе. Например, имя, фамилию, возраст, пол.
Мы знаем, что HTTP — это текстовый протокол, поэтому в запросе и ответе могут быть только текстовые данные. Поэтому нам нужно передать массив пользователей в текстовом виде. В этом нам поможет сериализация — процесс преобразования данных в строку. Сервер сериализовывает массив пользователей в строку и передает клиенту. Клиент может десериализовать строку обратно в массив структур пользователей.
Десериализация — это процесс преобразования сериализованной строки обратно в данные, которое понимает приложение.
На схеме ниже показано, как происходит сериализация и десериализация данных при отправке HTTP-ответа от сервера к клиенту:
Сервер сериализует объекты пользователей в строку, отправляет это в теле HTTP-ответа, а клиент читает тело ответа и десериализует строку обратно в данные.
Существует множество протоколов сериализации данных. Они отличаются способами преобразования данных в строку и форматами сериализованной строки. Наиболее популярные протоколы сериализации данных: JSON, XML, YAML, MessagePack и Protocol Buffers.
В этом курсе мы разберем самый популярный протокол сериализации данных — JSON. У него есть следующие преимущества:
- Простой в изучении, чтении и понимании
- Поддерживается большинством языков программирования
- Формат достаточно компактный по сравнению с широко используемым в прошлом XML
Перед тем, как продолжить, ознакомьтесь с этим форматом сериализации в документации .
Для сериализации и десериализации данных в JSON используется стандартная библиотека. Для этого в ней есть две функции:
- json.Marshal() — сериализует данные в JSON
- json.Unmarshal() — десериализует данные из JSON
Так в GO происходит сериализация и десериализация структуры:
package main import ( "encoding/json" "fmt" "log" ) type User struct ID int64 `json:"id"` Email string `json:"email"` Name string `json:"name"` Age int `json:"age,omitempty"` password string > func main() user := User ID: 222, Email: "john@doe.com", Name: "John", Age: 25, password: "secret", > // Сериализация структуры в строку jsonBytes, err := json.Marshal(&user) if err != nil // Используем Fatal только для примера, // нельзя использовать в реальных приложениях log.Fatalln("marshal ", err.Error()) > fmt.Printf("JSON string: %s\n", string(jsonBytes)) // Десериализация строки в структуру deserializedUser := User<> err = json.Unmarshal(jsonBytes, &deserializedUser) if err != nil // Используем Fatal только для примера, // нельзя использовать в реальных приложениях log.Fatalln("unmarshal ", err.Error()) > fmt.Printf("Deserialized user struct: %+v\n", deserializedUser) > При запуске программы видим вывод:
"id":222,"email":"john@doe.com","name":"John","age":25> Deserialized user struct: ID:222 Email:john@doe.com Name:John Age:25 password:> В данном Go-приложении мы преобразовали объект пользователя User в JSON-строку и обратно. В результате мы получили ту же структуру User, но с пустым полем password, потому что указали, что это приватное поле. Если бы мы отправили такую JSON-строку по сети другому веб-приложению, то оно смогло бы восстановить изначальный объект User без поля password.
Важные моменты работы с JSON в Go:
- В структуре сериализуются только публичные свойства, которые написаны с заглавной буквы. В нашем примере свойство password — приватное, поэтому оно не попало в JSON-строку. Такое же правило действует и на десериализацию. Если мы добавим значение password в JSON-строку, то это значение все равно не попадет в десериализованную структуру
- В JSON-строке можно указывать название свойства, которое будет отличаться от названия свойства в структуре. Для этого используется тег json:»» . В нашем примере мы указали тег для свойства ID в виде json:»id» . Так можно указывать, в каком виде должно называться свойство в JSON-строке в зависимости от соглашений в проекте
- При описании тега json:»» можно указать опцию omitempty . Эта опция говорит о том, что если значение свойства является нулевым, то это поле не нужно включать в сериализованную строку
Мы научились работать с JSON в Golang, теперь рассмотрим, как использовать этот формат в веб-приложениях.
JSON в веб-приложении
В веб-приложениях JSON используется, чтобы обменивать данные между клиентом и сервером. Клиент может отправлять HTTP-запрос с телом запроса в формате JSON, а сервер может возвращать HTTP-ответ с телом в формате JSON.
Веб-клиент отправляет JSON в теле запроса в случае, когда нужно изменить состояние чего-либо. Например, если пользователь заполнил форму регистрации, то веб-клиент отправит JSON с данными формы на сервер. Сервер в этом случае сохранит нового пользователя в базе данных.
Сервер возвращает ответ с JSON, когда клиент запрашивает данные. Например, клиент запросил список курсов на Хекслете, и сервер вернул JSON массив структур курсов.
Реализуем эти концепции на примере Fiber веб-приложения. В Fiber работа с JSON происходит через контекст запроса c *fiber.Ctx . Для этого есть два метода:
- c.BodyParser() — преобразует JSON-тело запроса в объект
- c.JSON() — отправляет JSON-строку в теле ответа
Реализуем веб-приложение для сохранения логов, в котором отправим JSON в теле запроса и получим JSON в теле ответа.
В приложении будет единственный метод /logs , который будет принимать POST-запросы на сохранение записи. В теле запроса передается структура одной записи логов. В ответе веб-приложение возвращает структуру с идентификатором сохраненной записи:
package main import ( "fmt" "github.com/gofiber/fiber/v2" "github.com/google/uuid" "github.com/sirupsen/logrus" ) type ( CreateLogEntryRequest struct Message string `json:"message"` Level string `json:"level"` Timestamp int64 `json:"timestamp"` > CreateLogEntryResponse struct ID string `json:"id"` > LogEntry struct ID string Message string Level string Timestamp int64 > ) var logs []LogEntry func main() webApp := fiber.New() webApp.Post("/logs", func(c *fiber.Ctx) error var request CreateLogEntryRequest if err := c.BodyParser(&request); err != nil return fmt.Errorf("body parser: %w", err) > logEntry := LogEntry ID: uuid.New().String(), Message: request.Message, Level: request.Level, Timestamp: request.Timestamp, > // Упрощенное хранение в памяти приложения logs = append(logs, logEntry) return c.JSON(CreateLogEntryResponse ID: logEntry.ID, >) >) logrus.Fatal(webApp.Listen(":80")) > Запускаем веб-приложение и отправляем запрос на сохранение тестовой записи:
--location --request POST 'http://localhost/logs' \ --header 'Content-Type: application/json' \ --data-raw '' В ответ получаем идентификатор:
"id":"8a53055f-6fcc-435a-b2be-35abc978a9ed"> В данном веб-приложении мы описали структуры запроса и ответа с публичными свойствами и JSON-тегами. Благодаря этому, мы смогли использовать структуру запроса CreateLogEntryRequest в методе c.BodyParser() , чтобы десериализовать тела запроса из JSON. Также мы использовали структуру ответа CreateLogEntryResponse в методе c.JSON() , чтобы сериализовать тела ответа в JSON.
Выводы
В этом уроке мы изучили, что такое сериализация — процесс преобразования структур данных в строку. И десериализация — процесс преобразования сериализованной строки обратно в данные.
Еще мы разобрали самый популярный формат сериализации данных — JSON, так как он простой в генерации и чтении по сравнению с аналогами.
Напомним еще несколько важных моментов из урока:
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: