Adatszerializáció a mobilfejlesztésben: lényeg, formátumok és hogyan működik

A szerializáció és deszerializáció lényege

A szerializáció az alkalmazás objektumának olyan formátumba alakítása, amely alkalmas hálózaton keresztüli továbbításra vagy lemezre mentésre. A deszerializáció végrehajtja a fordított átalakítást, visszaállítva az objektumot a kapott adatokból. A mobilfejlesztésben a szerializációt API-kéréseknél, képernyőállapot mentésénél, gyorsítótárazásnál és adatok Intent vagy Bundle segítségével történő továbbításánál alkalmazzák.

Mikor merül fel a szükség

Az alkalmazás komponensei vagy az alkalmazás és a szerver közötti minden interakció szerializációt igényel. A REST API adatokat JSON vagy XML formátumban továbbít, a gRPC a Protocol Buffers-t használja, az Androidon belüli folyamatok közötti kommunikáció pedig a Parcelable-t alkalmazza. Szerializáció nélkül lehetetlen egy összetett objektumot a folyamathatáron átjuttatni vagy adatbázisban elmenteni.

// A szerializáció általános elve
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Szerializáció: objektum -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// Deszerializáció: JSON -> objektum
fun deserializeUser(json: String): User? {
    // JSON elemzése objektummá
    return Gson().fromJson(json, User::class.java)
}

JSON — a mobilfejlesztés fő formátuma

JSON (JavaScript Object Notation) egy könnyű szöveges formátum, amely a JavaScript objektumainak szintaxisán alapul. A JSON támogatja a karakterláncokat, számokat, logikai értékeket, tömböket és beágyazott objektumokat, ami lefedi a mobilalkalmazások adatátviteli forgatókönyveinek többségét. A formátum platformfüggetlen: minden ökoszisztéma beépített eszközöket biztosít az elemzéséhez.

A JSON előnyei az alternatívákkal szemben

A JSON egyszerűsége és egyetemessége miatt győz. A fejlesztőnek nincs szüksége sémára az alapvető használathoz — a szerkezet dinamikusan, az elemzés során határozódik meg. A formátum olvashatósága leegyszerűsíti a hibakeresést és tesztelést: a szerver válasza bármely fejlesztői eszközben megtekinthető. Mindkét mobil platformon a JSON natívan feldolgozható külső könyvtárak csatlakoztatása nélkül.

// Codable — natív JSON szerializáció Swift-ben
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 a Google-tól

Protocol Buffers (protobuf) a Google által kifejlesztett bináris szerializációs formátum nagy teljesítményű rendszerek számára. A JSON-tól eltérően a protobuf előzetes séma meghatározást igényel .proto fájlban, de lényegesen kisebb adatméretet és nagyobb feldolgozási sebességet biztosít. A formátumot a gRPC, a Firebase Firestore és a Google belső szolgáltatásai használják.

A .proto fájl szerkezete

A protobuf séma tipizált mezőkkel rendelkező üzeneteket ír le, amelyek mindegyike egyedi számmal rendelkezik. A protoc fordító osztályokat generál a kívánt nyelven, amelyek automatikusan végrehajtják a szerializációt és deszerializációt. A Protobuf támogatja a séma evolúcióját a mezők hozzáadásának és eltávolításának szabályain keresztül anélkül, hogy elveszítené a visszafelé kompatibilitást.

// Séma meghatározása a user.proto fájlban
syntax = "proto3";

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

// Generált kód Kotlin-ban
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML és alkalmazása

XML (eXtensible Markup Language) szigorú szerkezettel, névtér-támogatással és XSD sémákon keresztüli érvényesítéssel rendelkező formátum. Az XML veszít a JSON-nal szemben a tömörség és az elemzési sebesség tekintetében, de továbbra is keresett az Android fejlesztésben az elrendezés fájlokhoz, AndroidManifest-hez, erőforrásokhoz és Gradle konfigurációkhoz. iOS-en az XML-t plist fájlokban és néhány régebbi szolgáltatásban használják.

XML elemzés Androidon

Az Android három XML elemzési módot kínál: DOM (a teljes dokumentum betöltése a memóriába), SAX (eseményorientált streamelemzés) és XmlPullParser (hibrid megközelítés). Az XmlPullParser az ajánlott lehetőség mobil eszközökhöz, mivel hatékonyan működik korlátozott memóriával, és lehetővé teszi a dokumentum feldolgozását olvasás közben.

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

Szerializáció iOS és Android rendszereken

Minden platform saját eszközöket kínál a szerializációhoz. iOS-en a fő mechanizmus a Codable protokoll JSONEncoder és JSONDecoder osztályokkal, Objective-C esetén pedig az NSJSONSerialization. Az Android a Gson, Moshi és kotlinx.serialization könyvtárakat használja. A folyamatok közötti adatátvitelhez az Android a Parcelable-t, az iOS pedig az NSKeyedArchiver-t alkalmazza. A Kotlin projektek egyre gyakrabban választják a kotlinx.serialization-t — a JetBrains megoldását, amely támogatja a többplatformos fejlesztést és nem függ a reflektiótól, a szerializátorokat a fordítási fázisban generálva a Kotlin fordító pluginjén keresztül.

Parcelable vs Serializable Androidon

Az Android két szerializációs mechanizmust támogat az Intent és Bundle számára. A Serializable a szabványos Java mechanizmus, amely reflektiót használ, ami alacsony teljesítményhez vezet. A Parcelable egy Android-specifikus protokoll, amely a writeToParcel és createFromParcel metódusok kézi megvalósítását igényli, de tízszer gyorsabban működik a bájtok közvetlen manipulálásának köszönhetően.

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

// Adatátvitel Intent segítségével
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

iOS-en a vezérlők közötti adatátvitelhez a Codable-t használják előzetes Data szerializációval, a folyamatok közötti kommunikációhoz pedig az NSKeyedArchiver-t, amely az objektumokat Property List bináris formátumba alakítja. A SwiftUI modern projektjei előnyben részesítik az adatok JSONEncoder segítségével történő kódolását az alkalmazásmodulok közötti továbbításhoz.

Biztonság a szerializációnál

A megbízhatatlan adatok helytelen deszerializációja sebezhetőségekhez vezethet. A szerializáción keresztüli támadások a Java felülírt readObject metódusait vagy a harmadik féltől származó könyvtárak nem biztonságos deszerializátorait használják ki. Androidon kerülni kell a Serializable használatát megbízhatatlan forrásokból származó adatok esetén, helyette Parcelable-t vagy az összes mező kézi érvényesítését kell alkalmazni a deszerializáció után. iOS-en a JSONDecoder alapértelmezés szerint szigorú a típusokkal szemben, de a JSONSerialization használatakor a fejlesztőnek ellenőriznie kell a típusokat feltételes konverzióval.

A formátum kiválasztása a projekthez

A szerializációs formátum kiválasztásakor figyelembe veszik a teljesítménykövetelményeket, az adatméretet és a kompatibilitást. REST API és mikroszolgáltatás-architektúra esetén az optimális választás továbbra is a JSON — minden platform és nyelv támogatja. Nagy terhelésű rendszerek és korlátozott forgalmú mobilalkalmazások esetén a Protocol Buffers előnyösebb, amely kisebb méretet és gyorsabb deszerializációt biztosít. Az XML csak konfigurációs forgatókönyvekben és örökölt rendszerekkel való integrációkor indokolt. A modern projektekben a FlatBuffers is egyre népszerűbb — bináris formátum deszerializációs fázis nélkül, amelyet játékmotorokban és minimális késleltetésű alkalmazásokban használnak. Minden formátumnak megvan a maga rése, és a helyes választás közvetlenül befolyásolja az alkalmazás működési sebességét és a felhasznált forgalom mennyiségét.