Dataserialisering inom mobilutveckling: essens, format och hur det fungerar

Essensen av serialisering och deserialisering

Serialisering är processen att omvandla ett applikationsobjekt till ett format som lämpar sig för överföring över nätverk eller lagring på disk. Deserialisering utför den omvända konverteringen och återställer objektet från mottagen data. Inom mobilutveckling tillämpas serialisering vid API-begäranden, lagring av skärmtillstånd, cachning och dataöverföring via Intent eller Bundle.

När behov uppstår

Varje interaktion mellan applikationskomponenter eller mellan applikationen och servern kräver serialisering. REST API överför data i JSON eller XML, gRPC använder Protocol Buffers och intraprocesskommunikation på Android använder Parcelable. Utan serialisering är det omöjligt att skicka ett komplext objekt över processgränsen eller spara det i databasen.

// Allmän princip för serialisering
data class User(
    val id: Int,
    val name: String,
    val email: String
)

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

// Deserialisering: JSON -> objekt
fun deserializeUser(json: String): User? {
    // tolkning av JSON till objekt
    return Gson().fromJson(json, User::class.java)
}

JSON — huvudformatet för mobilutveckling

JSON (JavaScript Object Notation) är ett lättviktigt textformat baserat på syntaxen för JavaScript-objekt. JSON stöder strängar, nummer, booleska värden, arrayer och nästlade objekt, vilket täcker de flesta scenarierna för dataöverföring i mobilapplikationer. Formatet är plattformsoberoende: varje ekosystem tillhandahåller inbyggda verktyg för att tolka det.

Fördelar med JSON jämfört med alternativ

JSON vinner på grund av sin enkelhet och universalitet. Utvecklaren behöver inget schema för grundläggande användning — strukturen bestäms dynamiskt under tolkningen. Formatets läsbarhet förenklar felsökning och testning: serverns svar kan visas i vilket utvecklarverktyg som helst. På båda mobilplattformarna bearbetas JSON inbyggt utan att ansluta externa bibliotek.

// Codable — inbyggd JSON-serialisering i 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 från Google

Protocol Buffers (protobuf) är ett binärt serialiseringsformat utvecklat av Google för högpresterande system. Till skillnad från JSON kräver protobuf fördefiniering av schemat i en .proto-fil, men ger betydligt mindre datastorlek och högre bearbetningshastighet. Formatet används i gRPC, Firebase Firestore och Googles interna tjänster.

Struktur för .proto-fil

Protobuf-schemat beskriver meddelanden med typade fält, var och en med ett unikt nummer. Protoc-kompilatorn genererar klasser på önskat språk som automatiskt utför serialisering och deserialisering. Protobuf stöder schemaevolution genom regler för att lägga till och ta bort fält utan förlust av bakåtkompatibilitet.

// Definition av schema i user.proto
syntax = "proto3";

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

// Genererad kod i Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML och dess tillämpning

XML (eXtensible Markup Language) är ett format med strikt struktur, stöd för namnrymder och validering genom XSD-scheman. XML förlorar mot JSON i kompakthet och tolkningshastighet, men är fortfarande efterfrågat inom Android-utveckling för layoutfiler, AndroidManifest, resurser och Gradle-konfigurationer. På iOS används XML i plist-filer och vissa äldre tjänster.

Tolkning av XML på Android

Android erbjuder tre sätt att tolka XML: DOM (laddar hela dokumentet i minnet), SAX (händelsestyrd strömningstolkning) och XmlPullParser (hybridmetod). XmlPullParser är det rekommenderade alternativet för mobila enheter eftersom det arbetar effektivt med begränsat minne och tillåter bearbetning av dokumentet medan det läses.

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

Serialisering på iOS och Android

Varje plattform erbjuder sina egna verktyg för serialisering. På iOS är huvudmekanismen protokollet Codable med JSONEncoder och JSONDecoder, och för Objective-C — NSJSONSerialization. Android använder biblioteken Gson, Moshi och kotlinx.serialization. För dataöverföring mellan processer använder Android Parcelable och iOS använder NSKeyedArchiver. Kotlin-projekt väljer allt oftare kotlinx.serialization — en lösning från JetBrains som stöder multiplattform och inte är beroende av reflektion, vilket genererar serialiserare under kompileringsfasen genom ett Kotlin-kompilatorplugin.

Parcelable vs Serializable på Android

Android stöder två serialiseringsmekanismer för Intent och Bundle. Serializable är standard Java-mekanismen som använder reflektion, vilket leder till låg prestanda. Parcelable är ett Android-specifikt protokoll som kräver manuell implementering av metoderna writeToParcel och createFromParcel, men fungerar tiotals gånger snabbare tack vare direkt manipulering av byte.

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

// Överföring via Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

På iOS används Codable med föregående serialisering till Data för dataöverföring mellan kontroller, och för interprocesskommunikation — NSKeyedArchiver, som omvandlar objekt till binärt Property List-format. Moderna projekt i SwiftUI föredrar att koda data via JSONEncoder för överföring mellan applikationsmoduler.

Säkerhet vid serialisering

Felaktig deserialisering av otillförlitlig data kan leda till sårbarheter. Attacker via serialisering utnyttjar överskrivna readObject-metoder i Java eller osäkra deserialiserare från tredjepartsbibliotek. På Android bör Serializable undvikas för data från otillförlitliga källor, istället använda Parcelable eller manuell validering av alla fält efter deserialisering. På iOS är JSONDecoder som standard strikt mot typer, men vid arbete med JSONSerialization måste utvecklaren kontrollera typer genom villkorlig konvertering.

Val av format för projektet

Vid val av serialiseringsformat beaktas prestandakrav, datastorlek och kompatibilitet. För REST API och mikrotjänstarkitektur förblir JSON det optimala valet — det stöds av alla plattformar och språk. För högbelastade system och mobilapplikationer med begränsad trafik är Protocol Buffers att föredra, vilka ger mindre storlek och snabbare deserialisering. XML är endast motiverat i konfigurationsscenarier och vid integration med äldre system. I moderna projekt vinner även FlatBuffers popularitet — ett binärt format utan deserialiseringsfas, som används i spelmotorer och applikationer med minimal latens. Varje format har sin nisch och rätt val påverkar direkt applikationens hastighet och mängden förbrukad trafik.