Datenserialisierung in der mobilen Entwicklung: Wesen, Formate und Funktionsweise

Wesen der Serialisierung und Deserialisierung

Serialisierung ist der Prozess der Umwandlung eines Anwendungsobjekts in ein Format, das für die Netzwerkübertragung oder die Speicherung auf der Festplatte geeignet ist. Die Deserialisierung führt die umgekehrte Umwandlung durch und stellt das Objekt aus den empfangenen Daten wieder her. In der mobilen Entwicklung wird die Serialisierung bei API-Anfragen, beim Speichern von Bildschirmzuständen, beim Caching und bei der Datenübertragung über Intent oder Bundle verwendet.

Wann die Notwendigkeit entsteht

Jede Interaktion zwischen Anwendungskomponenten oder zwischen der Anwendung und dem Server erfordert eine Serialisierung. REST-APIs übertragen Daten in JSON oder XML, gRPC verwendet Protocol Buffers und die Intraprozesskommunikation auf Android verwendet Parcelable. Ohne Serialisierung ist es unmöglich, ein komplexes Objekt über eine Prozessgrenze hinweg zu übergeben oder in einer Datenbank zu speichern.

// Allgemeines Prinzip der Serialisierung
data class User(
    val id: Int,
    val name: String,
    val email: String
)

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

// Deserialisierung: JSON -> Objekt
fun deserializeUser(json: String): User? {
    // Parsen von JSON zu Objekt
    return Gson().fromJson(json, User::class.java)
}

JSON — das Hauptformat der mobilen Entwicklung

JSON (JavaScript Object Notation) ist ein leichtes Textformat, das auf der JavaScript-Objektsyntax basiert. JSON unterstützt Zeichenketten, Zahlen, boolesche Werte, Arrays und verschachtelte Objekte und deckt die meisten Datenübertragungsszenarien in mobilen Anwendungen ab. Das Format ist plattformunabhängig: Jedes Ökosystem bietet integrierte Werkzeuge für seine Analyse.

Vorteile von JSON gegenüber Alternativen

JSON überzeugt durch seine Einfachheit und Vielseitigkeit. Der Entwickler benötigt für die grundlegende Nutzung kein Schema — die Struktur wird während des Parsens dynamisch bestimmt. Die Lesbarkeit des Formats vereinfacht das Debugging und Testen: Die Serverantwort kann in jedem Entwicklerwerkzeug eingesehen werden. Auf beiden mobilen Plattformen wird JSON nativ ohne die Notwendigkeit von Drittanbieterbibliotheken verarbeitet.

// Codable — native JSON-Serialisierung in 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 von Google

Protocol Buffers (protobuf) ist ein binäres Serialisierungsformat, das von Google für leistungsstarke Systeme entwickelt wurde. Im Gegensatz zu JSON erfordert protobuf ein vordefiniertes Schema in einer .proto-Datei, bietet aber eine deutlich geringere Datengröße und eine höhere Verarbeitungsgeschwindigkeit. Das Format wird in gRPC, Firebase Firestore und internen Google-Diensten verwendet.

Aufbau einer .proto-Datei

Ein protobuf-Schema beschreibt Nachrichten mit typisierten Feldern, die jeweils eine eindeutige Nummer haben. Der protoc-Compiler generiert Klassen in der Zielsprache, die die Serialisierung und Deserialisierung automatisch durchführen. Protobuf unterstützt die Schemaentwicklung durch Regeln zum Hinzufügen und Entfernen von Feldern, ohne die Abwärtskompatibilität zu verlieren.

// Schemadefinition in user.proto
syntax = "proto3";

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

// Generierter Code in Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML und seine Anwendung

XML (eXtensible Markup Language) ist ein Format mit starrer Struktur, Namespace-Unterstützung und Validierung durch XSD-Schemata. XML unterliegt gegenüber JSON in Kompaktheit und Parsing-Geschwindigkeit, bleibt aber in der Android-Entwicklung für Layout-Dateien, AndroidManifest, Ressourcen und Gradle-Konfigurationen gefragt. Auf iOS wird XML in plist-Dateien und einigen Legacy-Diensten verwendet.

XML-Parsing auf Android

Android bietet drei Ansätze für das XML-Parsing: DOM (Laden des gesamten Dokuments in den Speicher), SAX (ereignisgesteuertes Streaming-Parsing) und XmlPullParser (ein hybrider Ansatz). XmlPullParser ist die empfohlene Option für mobile Geräte, da er effizient mit begrenztem Speicher arbeitet und die Verarbeitung des Dokuments während des Lesens ermöglicht.

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

Serialisierung auf iOS und Android

Jede Plattform bietet ihre eigenen Serialisierungswerkzeuge. Auf iOS ist der primäre Mechanismus das Codable-Protokoll mit JSONEncoder und JSONDecoder, während Objective-C NSJSONSerialization verwendet. Android verwendet die Bibliotheken Gson, Moshi und kotlinx.serialization. Für die Datenübertragung zwischen Prozessen verwendet Android Parcelable, während iOS NSKeyedArchiver verwendet. Kotlin-Projekte wählen zunehmend kotlinx.serialization — eine Lösung von JetBrains, die Multiplattform unterstützt und nicht auf Reflektion angewiesen ist, indem sie Serialisierer zur Kompilierungszeit über das Kotlin-Compiler-Plugin generiert.

Parcelable vs. Serializable auf Android

Android unterstützt zwei Serialisierungsmechanismen für Intent und Bundle. Serializable ist ein standardmäßiger Java-Mechanismus, der Reflektion verwendet, was zu einer geringeren Leistung führt. Parcelable ist ein Android-spezifisches Protokoll, das eine manuelle Implementierung der Methoden writeToParcel und createFromParcel erfordert, aber aufgrund der direkten Byte-Manipulation um ein Vielfaches schneller arbeitet.

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

// Übertragung via Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

Auf iOS wird Codable mit vorheriger Serialisierung in Data für die Datenübertragung zwischen Controllern verwendet, während NSKeyedArchiver für die Interprozesskommunikation verwendet wird, der Objekte in das binäre Property List-Format umwandelt. Moderne SwiftUI-Projekte bevorzugen die Kodierung von Daten über JSONEncoder zur Übertragung zwischen Anwendungsmodulen.

Sicherheit bei der Serialisierung

Eine fehlerhafte Deserialisierung nicht vertrauenswürdiger Daten kann zu Sicherheitslücken führen. Angriffe durch Serialisierung nutzen überschriebene readObject-Methoden in Java oder unsichere Deserialisierer von Drittanbieterbibliotheken aus. Auf Android sollte Serializable für Daten aus nicht vertrauenswürdigen Quellen vermieden werden, stattdessen sollte Parcelable oder eine manuelle Validierung aller Felder nach der Deserialisierung verwendet werden. Auf iOS ist JSONDecoder standardmäßig streng in Bezug auf Typen, aber bei der Arbeit mit JSONSerialization müssen Entwickler die Typen durch bedingte Typumwandlung überprüfen.

Auswahl eines Formats für das Projekt

Bei der Auswahl eines Serialisierungsformats werden die Leistungsanforderungen, die Datengröße und die Kompatibilität berücksichtigt. Für REST-APIs und Microservice-Architektur bleibt JSON die optimale Wahl — es wird von allen Plattformen und Sprachen unterstützt. Für hochbelastete Systeme und mobile Anwendungen mit begrenzter Bandbreite sind Protocol Buffers vorzuziehen, die eine kleinere Größe und eine schnellere Deserialisierung bieten. XML ist nur in Konfigurationsszenarien und bei der Integration mit Legacy-Systemen gerechtfertigt. In modernen Projekten gewinnt auch FlatBuffers an Popularität — ein binäres Format ohne Deserialisierungsschritt, das in Spiele-Engines und Anwendungen mit minimaler Latenz verwendet wird. Jedes Format hat seine Nische, und die richtige Wahl wirkt sich direkt auf die Geschwindigkeit der Anwendung und die Menge des verbrauchten Datenverkehrs aus.