Parsing in mobilen Apps: Wesen, Datenformate und Prozess

Was ist Parsing?

Parsing (syntaktische Analyse) ist der Prozess der Umwandlung einer Zeichenfolge in eine strukturierte Darstellung, die für die programmatische Verarbeitung geeignet ist. Im Kontext der mobilen Entwicklung bezeichnet Parsing die Verarbeitung von Serverantworten, Konfigurationsdateien, lokalem Cache und Ressourcendateien. Jedes Format erfordert seinen eigenen Ansatz: JSON — leichtgewichtig und ins SDK integriert, XML — streng mit XSD-Schema-Validierung, CSV — minimalistisch für tabellarische Daten, Protobuf — binär mit starrem Schema.

Phasen der syntaktischen Analyse

Jeder Parser durchläuft unabhängig vom Format drei Phasen. Lexikalische Analyse zerlegt den rohen Text in Tokens: Schlüssel, Zeichenketten, Zahlen, Trennzeichen und Kommentare. Syntaktische Analyse prüft die grammatikalische Korrektheit — Klammerbalance in JSON, korrekte Tag-Verschachtelung in XML. Aufbau der Ausgabestruktur erzeugt eine Objektdarstellung: JSONObject, Map oder einen Token-Stream zur weiteren Verarbeitung. Laut Apple (2026) verwendet der integrierte Foundation-Parser auf iOS faules Parsing — er validiert nur den Anfang von JSON und spart so Ressourcen.

Manuelles Parsing vs. automatisierte Bibliotheken

Manuelles Parsing (JSONSerialization, XmlPullParser) gibt volle Kontrolle über den Prozess und ist nützlich für nicht standardisierte Formate oder wenn eine benutzerdefinierte Validierung jedes Feldes erforderlich ist. Automatisierte Bibliotheken (JSONDecoder, Moshi, kotlinx.serialization) beschleunigen die Entwicklung, verbergen aber Details der Fehlerbehandlung. Die Wahl hängt von den Anforderungen ab: Wenn die Datenstruktur dynamisch oder im Voraus unbekannt ist, ist manuelles Parsing vorzuziehen. Wenn das Schema festgelegt ist, reduziert die automatisierte Deserialisierung den Code um 60-70%.

Wie sich Parsing von Deserialisierung unterscheidet

Parsing ist eine breitere Operation: Es kann im Streaming-Modus erfolgen und erzeugt nicht zwangsläufig ein typisiertes Objekt. Deserialisierung ist ein spezifischer Fall des Parsings, dessen Ergebnis immer eine Instanz einer bekannten Klasse mit bestimmten Eigenschaftstypen ist. Ein JSON-Parser zerlegt ein Dokument in Map oder JsonElement, während ein Deserialisierer dasselbe JSON in ein User-, Order- oder Product-Objekt mit bekannten Feldern und deren Typen umwandelt.

Streaming-Parsing ist der Hauptvorteil des Parsings gegenüber der Deserialisierung. XmlPullParser auf Android analysiert XML beim Lesen, ohne das gesamte Dokument in den RAM zu laden. Dies ist kritisch für große API-Antworten, das Parsen von RSS-Feeds mit Hunderten von Einträgen oder die Verarbeitung von Arrays mit Tausenden von JSON-Objekten aus einem Server-Dump. Ein Streaming-Parser liest Token für Token und verbraucht eine konstante Menge Speicher, unabhängig von der Dokumentgröße.

JSON-Parsing in mobilen Apps

JSON ist das dominierende Datenaustauschformat. Auf iOS parst das integrierte JSONSerialization JSON in Any, während JSONDecoder direkt in eine Codable-Struktur parst. Auf Android stellt das standardmäßige org.json JSONObject und JSONArray für manuelles Parsing bereit. Gson und Moshi fügen automatische Konvertierung hinzu. Die Wahl zwischen manuellen und automatisierten Ansätzen ist die erste Architekturentscheidung der Netzwerkschicht.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // Benutzerverarbeitung
}

Manuelles Parsing mit org.json ist nützlich, wenn die Antwortstruktur im Voraus unbekannt ist oder stark variiert. Dieser Ansatz bietet volle Kontrolle über die Fehlerbehandlung und nullable-Felder, erfordert aber mehr Boilerplate-Code im Vergleich zur automatisierten Deserialisierung. Für kleine Projekte oder Prototypen ist dies akzeptabel, aber in der Produktion werden Moshi oder kotlinx.serialization bevorzugt.

JsonReader für Streaming-Parsing

JsonReader aus der Moshi-Bibliothek ist ein leistungsstarkes Werkzeug für das Streaming-JSON-Parsing. Es liest das Dokument Token für Token mit Methoden wie beginObject, nextName, nextString, nextInt und endObject. Dieser Ansatz ermöglicht die Verarbeitung von Dokumenten jeder Größe mit konstantem Speicherverbrauch. Laut Google (2026) ist Streaming-Parsing mit JsonReader 2- bis 3-mal schneller als das Laden des gesamten Dokuments in ein JsonObject und verbraucht bis zu 80% weniger Speicher.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

Das Beispiel zeigt JsonReader beim Streaming-Parsing von JSON. Jeder Aufruf von nextName() und nextInt() bewegt den Cursor zum nächsten Token. skipValue() überspringt unnötige Felder ohne sie zu parsen — besonders nützlich, wenn JSON 50 Felder enthält, aber nur 3 benötigt werden. Das Ergebnis ist minimaler Speicherverbrauch und maximale Geschwindigkeit.

XML- und CSV-Parsing

XML wird weiterhin in Android-Projekten für Ressourcen und in SOAP-Diensten von Unternehmensanwendungen verwendet. Auf Android bietet der integrierte XmlPullParser Streaming-Parsing mit minimalem Speicherverbrauch — er lädt keinen DOM-Baum, sondern erzeugt START_TAG-, TEXT- und END_TAG-Ereignisse. iOS verwendet XMLParser mit einem Delegaten-Ansatz: Die Methoden parser(didStartElement:) und parser(foundCharacters:) verarbeiten die Elemente sequenziell.

CSV in der mobilen Entwicklung

CSV ist das einfachste Format zum Exportieren und Importieren von tabellarischen Daten. In mobilen Apps wird CSV zum Exportieren von Berichten, zum Laden von Referenzdaten (Länderlisten, Währungen, Codes) und zur Offline-Datensynchronisation verwendet. Für das CSV-Parsing eignen sich Streaming-Bibliotheken: Apache Commons CSV und OpenCSV verarbeiten Dateien zeilenweise und maskieren Anführungszeichen und Kommas innerhalb von Werten. Auf iOS kann CSV-Parsing mit der NSString.components(separatedBy:)-Delimiter-Methode unter Behandlung von Randfällen implementiert werden.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Beispiel eines XMLParser-Delegaten auf iOS zum Parsen eines RSS-Feeds. Die Methode didStartElement wird bei jedem öffnenden Tag aufgerufen, foundCharacters gibt den Textinhalt zwischen Tags zurück, didEndElement schließt das Element ab. Diese ereignisbasierte Architektur ermöglicht die Verarbeitung von XML jeder Größe, ohne einen DOM-Baum in den Speicher zu laden — kritisch für die begrenzten Ressourcen mobiler Geräte.

Vergleich von CSV-Bibliotheken für Android

Auf Android hängt die Wahl des CSV-Parsers vom Datenvolumen ab. OpenCSV unterstützt eine fließende API, Annotationen für POJO-Mapping und benutzerdefinierte Trennzeichen. Apache Commons CSV ist niedrigerer Ebene, aber schneller bei großen Dateien. Für einfache Fälle (1-2 Spalten) ist manuelles Parsing mit String.split(",") und Escape-Behandlung ausreichend. Für Produktionsprojekte mit großen CSV-Dateien wird OpenCSV empfohlen.

Protobuf und Streaming-Parsing

Protocol Buffers von Google ist ein binäres Serialisierungsformat, das JSON in Geschwindigkeit und Kompaktheit übertrifft. Eine Protobuf-Nachricht benötigt 3- bis 6-mal weniger Platz als äquivalentes JSON und wird dank des binären Formats und des starren Schemas 4- bis 10-mal schneller geparst. Die Hauptnachteile sind die fehlende Lesbarkeit für Menschen und die Notwendigkeit, Code aus .proto-Dateien mit dem protoc-Compiler zu generieren.

Streaming-Parsing von Protobuf wird über CodedInputStream implementiert — der Client liest Felder, während sie eintreffen, ohne die gesamte Nachricht zu laden. Jedes Feld hat ein Tag (Nummer + Typ), und der Parser kann unbekannte Felder überspringen. Laut Google (2026) verbraucht Streaming-Protobuf-Parsing bei der Verarbeitung von Nachrichten ab 1 MB bis zu 90% weniger Speicher, was für mobile Geräte mit begrenztem RAM kritisch ist. Protobuf-lite ist eine spezielle Version für Android, optimiert für die Größe des generierten Codes.