Сериализация данных в мобильной разработке: суть, форматы и как работает

Суть сериализации и десериализации

Сериализация — это процесс преобразования объекта приложения в формат, пригодный для передачи по сети или сохранения на диск. Десериализация выполняет обратное преобразование, восстанавливая объект из полученных данных. В мобильной разработке сериализация применяется в API-запросах, сохранении состояния экрана, кэшировании и передачи данных через Intent или Bundle.

Когда возникает необходимость

Любое взаимодействие между компонентами приложения или между приложением и сервером требует сериализации. REST API передают данные в JSON или XML, gRPC использует Protocol Buffers, а внутрипроцессное взаимодействие на Android применяет Parcelable. Без сериализации невозможно передать сложный объект через границу процесса или сохранить его в базу данных.

// Общий принцип сериализации
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Сериализация: объект -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// Десериализация: JSON -> объект
fun deserializeUser(json: String): User? {
    // парсинг JSON в объект
    return Gson().fromJson(json, User::class.java)
}

JSON — основной формат мобильной разработки

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

Преимущества JSON перед альтернативами

JSON выигрывает за счёт простоты и универсальности. Разработчику не нужна схема для базового использования — структура определяется динамически во время парсинга. Читаемость формата упрощает отладку и тестирование: ответ сервера можно просмотреть в любом инструменте разработчика. На обеих мобильных платформах JSON обрабатывается нативно без подключения сторонних библиотек.

// Codable — нативная сериализация JSON в Swift
struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

let jsonString = """{"id":1,"name":"John","email":"john@test.com"}"""
let jsonData = Data(jsonString.utf8)
let decoder = JSONDecoder()
let user = try! decoder.decode(User.self, from: jsonData)

Protocol Buffers от Google

Protocol Buffers (protobuf) — бинарный формат сериализации, разработанный Google для высокопроизводительных систем. В отличие от JSON, protobuf требует предварительного определения схемы в .proto-файле, но обеспечивает значительно меньший размер данных и более высокую скорость обработки. Формат используется в gRPC, Firebase Firestore и внутренних сервисах Google.

Структура .proto файла

Схема protobuf описывает сообщения с типизированными полями, каждое из которых имеет уникальный номер. Компилятор protoc генерирует классы на нужном языке, которые выполняют сериализацию и десериализацию автоматически. Protobuf поддерживает эволюцию схемы через правила добавления и удаления полей без потери обратной совместимости.

// Определение схемы в user.proto
syntax = "proto3";

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  repeated string roles = 4;
}

// Сгенерированный код на Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML и его применение

XML (eXtensible Markup Language) — формат с жёсткой структурой, поддержкой пространств имён и валидацией через XSD-схемы. XML проигрывает JSON в компактности и скорости парсинга, но остаётся востребованным в Android-разработке для layout-файлов, AndroidManifest, ресурсов и конфигураций Gradle. На iOS XML используется в plist-файлах и некоторых legacy-сервисах.

Парсинг XML на Android

Android предоставляет три способа парсинга XML: DOM (загрузка всего документа в память), SAX (событийно-ориентированный потоковый парсинг) и XmlPullParser (гибридный подход). XmlPullParser — рекомендуемый вариант для мобильных устройств, так как он эффективно работает с ограниченной памятью и позволяет обрабатывать документ по мере чтения.

// XmlPullParser на Android
fun parseUserXml(inputStream: InputStream): User? {
    val parser = Xml.newPullParser()
    parser.setInput(inputStream, Xml.Encoding.UTF_8.name)

    var id: Int? = null
    var name: String? = null
    var email: String? = null

    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.eventType == XmlPullParser.START_TAG
            && parser.name == "email") {
            email = parser.nextText()
        }
    }
    return User(id!!, name!!, email!!)
}

Сериализация на iOS и Android

Каждая платформа предлагает собственные инструменты для сериализации. На iOS основным механизмом является протокол Codable с JSONEncoder и JSONDecoder, а для Objective-C — NSJSONSerialization. Android использует библиотеки Gson, Moshi и kotlinx.serialization. Для передачи данных между процессами Android применяет Parcelable, а iOS — NSKeyedArchiver. Kotlin-проекты всё чаще выбирают kotlinx.serialization — решение от JetBrains, которое поддерживает мультиплатформенность и не зависит от рефлексии, генерируя сериализаторы на этапе компиляции через плагин компилятора Kotlin.

Parcelable vs Serializable на Android

Android поддерживает два механизма сериализации для Intent и Bundle. Serializable — стандартный Java-механизм, использующий рефлексию, что приводит к низкой производительности. Parcelable — Android-специфичный протокол, требующий ручной реализации методов writeToParcel и createFromParcel, но работающий в десятки раз быстрее за счёт прямого манипулирования байтами.

// Parcelable на Android
@Parcelize
data class UserParcel(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable

// Передача через Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

На iOS для передачи данных между контроллерами используется Codable с предварительной сериализацией в Data, а для межпроцессного взаимодействия — NSKeyedArchiver, который преобразует объекты в бинарный формат Property List. Современные проекты на SwiftUI предпочитают кодировать данные через JSONEncoder для передачи их между модулями приложения.

Безопасность при сериализации

Некорректная десериализация недоверенных данных может привести к уязвимостям. Атаки через сериализацию эксплуатируют переопределённые методы readObject в Java или небезопасные десериализаторы сторонних библиотек. На Android следует избегать Serializable для данных из ненадёжных источников, используя вместо него Parcelable или ручную валидацию всех полей после десериализации. На iOS JSONDecoder по умолчанию строг к типам, но при работе с JSONSerialization разработчик должен проверять типы через условное приведение.

Выбор формата для проекта

При выборе формата сериализации учитываются требования к производительности, размеру данных и совместимости. Для REST API и микросервисной архитектуры оптимальным выбором остаётся JSON — он поддерживается всеми платформами и языками. Для высоконагруженных систем и мобильных приложений с ограниченным трафиком предпочтительнее Protocol Buffers, которые обеспечивают меньший размер и более быструю десериализацию. XML оправдан только в конфигурационных сценариях и при интеграции с legacy-системами. В современных проектах также набирает популярность FlatBuffers — бинарный формат без этапа десериализации, используемый в игровых движках и приложениях с минимальными задержками. Каждый формат имеет свою нишу, и грамотный выбор напрямую влияет на скорость работы приложения и объём потребляемого трафика.