Serializace dat v mobilním vývoji: podstata, formáty a jak funguje

Podstata serializace a deserializace

Serializace je proces převodu objektu aplikace do formátu vhodného pro odeslání po síti nebo uložení na disk. Deserializace provádí opačný převod a obnovuje objekt z přijatých dat. V mobilním vývoji se serializace uplatňuje v API požadavcích, ukládání stavu obrazovky, ukládání do mezipaměti a přenosu dat přes Intent nebo Bundle.

Kdy vzniká potřeba

Každá interakce mezi komponentami aplikace nebo mezi aplikací a serverem vyžaduje serializaci. REST API přenášejí data v JSON nebo XML, gRPC používá Protocol Buffers a vnitroprocesová komunikace na Androidu využívá Parcelable. Bez serializace nelze přenést složitý objekt přes hranici procesu nebo jej uložit do databáze.

// Obecný princip serializace
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Serializace: objekt -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// Deserializace: JSON -> objekt
fun deserializeUser(json: String): User? {
    // parsování JSON do objektu
    return Gson().fromJson(json, User::class.java)
}

JSON — hlavní formát mobilního vývoje

JSON (JavaScript Object Notation) je lehký textový formát založený na syntaxi objektů JavaScriptu. JSON podporuje řetězce, čísla, booleovské hodnoty, pole a vnořené objekty, což pokrývá většinu scénářů přenosu dat v mobilních aplikacích. Formát je nezávislý na platformě: každý ekosystém poskytuje vestavěné nástroje pro jeho parsování.

Výhody JSON oproti alternativám

JSON vítězí díky své jednoduchosti a univerzálnosti. Vývojář nepotřebuje schéma pro základní použití — struktura se určuje dynamicky během parsování. Čitelnost formátu zjednodušuje ladění a testování: odpověď serveru lze zobrazit v jakémkoli vývojářském nástroji. Na obou mobilních platformách se JSON zpracovává nativně bez připojování externích knihoven.

// Codable — nativní serializace JSON ve 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 od Google

Protocol Buffers (protobuf) je binární serializační formát vyvinutý společností Google pro vysoce výkonné systémy. Na rozdíl od JSON vyžaduje protobuf předchozí definici schématu v souboru .proto, ale poskytuje výrazně menší velikost dat a vyšší rychlost zpracování. Formát se používá v gRPC, Firebase Firestore a interních službách Google.

Struktura .proto souboru

Schéma protobuf popisuje zprávy s typovanými poli, z nichž každé má jedinečné číslo. Kompilátor protoc generuje třídy v požadovaném jazyce, které automaticky provádějí serializaci a deserializaci. Protobuf podporuje evoluci schématu prostřednictvím pravidel přidávání a odebírání polí bez ztráty zpětné kompatibility.

// Definice schématu v user.proto
syntax = "proto3";

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

// Generovaný kód v Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML a jeho použití

XML (eXtensible Markup Language) je formát s přísnou strukturou, podporou jmenných prostorů a validací prostřednictvím schémat XSD. XML ztrácí oproti JSON v kompaktnosti a rychlosti parsování, ale zůstává žádaný ve vývoji pro Android pro soubory rozvržení, AndroidManifest, zdroje a konfigurace Gradle. Na iOS se XML používá v souborech plist a některých starších službách.

Parsování XML na Androidu

Android nabízí tři způsoby parsování XML: DOM (načtení celého dokumentu do paměti), SAX (událostmi řízené streamové parsování) a XmlPullParser (hybridní přístup). XmlPullParser je doporučenou volbou pro mobilní zařízení, protože efektivně pracuje s omezenou pamětí a umožňuje zpracovávat dokument během čtení.

// XmlPullParser na Androidu
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!!)
}

Serializace na iOS a Android

Každá platforma nabízí vlastní nástroje pro serializaci. Na iOS je hlavním mechanismem protokol Codable s JSONEncoder a JSONDecoder, pro Objective-C pak NSJSONSerialization. Android používá knihovny Gson, Moshi a kotlinx.serialization. Pro přenos dat mezi procesy Android používá Parcelable a iOS NSKeyedArchiver. Projekty v Kotlinu stále častěji volí kotlinx.serialization — řešení od JetBrains, které podporuje multiplatformnost a není závislé na reflexi, generuje serializátory ve fázi kompilace prostřednictvím pluginu kompilátoru Kotlin.

Parcelable vs Serializable na Androidu

Android podporuje dva serializační mechanismy pro Intent a Bundle. Serializable je standardní Java mechanismus využívající reflexi, což vede k nízkému výkonu. Parcelable je protokol specifický pro Android, který vyžaduje ruční implementaci metod writeToParcel a createFromParcel, ale díky přímé manipulaci s bajty pracuje desetkrát rychleji.

// Parcelable na Androidu
@Parcelize
data class UserParcel(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable

// Přenos přes Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

Na iOS se pro přenos dat mezi ovladači používá Codable s předchozí serializací do Data a pro meziprocesovou komunikaci NSKeyedArchiver, který převádí objekty do binárního formátu Property List. Moderní projekty ve SwiftUI preferují kódování dat přes JSONEncoder pro přenos mezi moduly aplikace.

Bezpečnost při serializaci

Nesprávná deserializace nedůvěryhodných dat může vést ke zranitelnostem. Útoky prostřednictvím serializace zneužívají přepsané metody readObject v Javě nebo nebezpečné deserializátory knihoven třetích stran. Na Androidu je třeba se vyhnout Serializable pro data z nedůvěryhodných zdrojů a místo toho použít Parcelable nebo ruční validaci všech polí po deserializaci. Na iOS je JSONDecoder standardně přísný vůči typům, ale při práci s JSONSerialization musí vývojář kontrolovat typy pomocí podmíněného převodu.

Výběr formátu pro projekt

Při výběru serializačního formátu se zohledňují požadavky na výkon, velikost dat a kompatibilitu. Pro REST API a mikroslužbovou architekturu zůstává optimální volbou JSON — je podporován všemi platformami a jazyky. Pro vysoce zatížené systémy a mobilní aplikace s omezeným provozem jsou preferovány Protocol Buffers, které poskytují menší velikost a rychlejší deserializaci. XML je odůvodněné pouze v konfiguračních scénářích a při integraci se staršími systémy. V moderních projektech získává na popularitě také FlatBuffers — binární formát bez fáze deserializace, používaný v herních enginech a aplikacích s minimální latencí. Každý formát má své místo a správná volba přímo ovlivňuje rychlost aplikace a objem spotřebovaného provozu.