JSONSerialization: was ist das, Methoden der Foundation-Klasse und wie es funktioniert

Was ist JSONSerialization

JSONSerialization ist eine Klasse des Foundation-Frameworks, die auf iOS, macOS, tvOS und watchOS verfügbar ist. Sie bietet Methoden zum Konvertieren von JSON Data in Foundation-Objekte (NSDictionary, NSArray, NSString, NSNumber) und zurück. Die Klasse erschien in iOS 5 und blieb bis zur Einführung von Codable (Swift 4) die primäre Methode zur Arbeit mit JSON auf Apple-Plattformen. Trotz ihres Alters ist JSONSerialization weiterhin in Legacy-Objective-C-Projekten und in Szenarien relevant, in denen eine dynamische JSON-Verarbeitung ohne festes Modellschema erforderlich ist.

Wann JSONSerialization verwendet wird

Trotz des Aufkommens von Codable bleibt JSONSerialization in mehreren Szenarien relevant. Dynamische JSON-Struktur — wenn sich das Antwortformat ändert oder im Voraus unbekannt ist — erfordert den Zugriff auf Wörterbücher über Schlüssel, was mit JSONSerialization einfacher zu bewerkstelligen ist. Die Klasse wird auch in Objective-C-Projekten verwendet, in denen Codable nicht verfügbar ist, sowie bei der Arbeit mit Streams für das inkrementelle Parsen großer JSON-Dateien. In Tests und Mockups ermöglichen isValidJSONObject und data(withJSONObject:options:) das schnelle Generieren von JSON-Fixtures ohne Drittanbieterbibliotheken, was die Entwicklung und das Prototyping beschleunigt.

import Foundation

// Grundlegende Struktur der Verwendung von JSONSerialization
let jsonString = """
{
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
}
"""

guard let jsonData = jsonString.data(using: .utf8) else {
    return
}

do {
    let json = try JSONSerialization
        .jsonObject(with: jsonData,
                       options: .mutableContainers)
    print(json)
} catch {
    print("JSON-Parsing-Fehler: \(error)")
}

Hauptmethoden der Klasse

JSONSerialization bietet vier Hauptmethoden für die Arbeit mit JSON. Die Hauptmethode ist jsonObject(with:options:), die Data in Foundation-Objekte konvertiert. Die Methode data(withJSONObject:options:) führt die umgekehrte Serialisierung durch. isValidJSONObject(_:) prüft, ob ein Objekt serialisiert werden kann. writeJSONObject(_:to:options:error:) schreibt JSON direkt in einen Stream. Zum Lesen von JSON aus InputStream gibt es die Methode jsonObject(with:options:), die einen Stream anstelle von Data akzeptiert, was bei der Integration mit Netzwerkanfragen, die Streaming-Daten zurückgeben, praktisch ist.

JSONObject und JSONData

Die Methode jsonObject akzeptiert Data und gibt Any zurück — normalerweise NSDictionary oder NSArray. Für eine sichere Verwendung wird das Ergebnis durch bedingtes Casting in den erwarteten Typ konvertiert. Die Methode data akzeptiert ein Foundation-Objekt und gibt Data mit einer JSON-Darstellung zurück. Die Option .prettyPrinted fügt Formatierung mit Einrückungen für die Lesbarkeit hinzu.

let jsonString = """
{
    "products": [
        {"id": 1, "name": "iPhone", "price": 999},
        {"id": 2, "name": "iPad", "price": 799}
    ]
}
"""
let data = Data(jsonString.utf8)

if let json = try? JSONSerialization
    .jsonObject(with: data) as? [String: Any],
    let products = json["products"] as? [[String: Any]] {

    for product in products {
        if let name = product["name"] as? String {
            print("Produkt: \(name)")
        }
    }
}

// Umgekehrte Serialisierung: Objekt -> JSON
let outputDict: [String: Any] = ["status": "ok", "count": 42]
if let outputData = try? JSONSerialization
    .data(withJSONObject: outputDict,
                options: .prettyPrinted) {
    String(data: outputData, encoding: .utf8)
}

Beispiele für JSON-Parsing

Basis-Parsing eines Wörterbuchs mit primitiven Typen ist die häufigste Operation mit JSONSerialization. Nach dem Empfangen von Data über URLSession ruft der Entwickler jsonObject auf und konvertiert das Ergebnis in den erwarteten Typ. Für Arrays von Objekten wird das Casting zu [[String: Any]] verwendet, wonach jedes Element in einer Schleife verarbeitet wird. Dieser Ansatz ist flexibel, erfordert jedoch manuelle Typverwaltung.

Parsing verschachtelter Strukturen

Reale APIs geben komplexe verschachtelte JSON-Objekte mit Arrays, Daten und optionalen Feldern zurück. JSONSerialization verarbeitet jede Verschachtelungstiefe korrekt, aber der Entwickler muss jede Ebene unabhängig in den erforderlichen Typ konvertieren. Um diese Aufgabe zu vereinfachen, empfiehlt Apple die Verwendung von Codable für typisierte Daten und JSONSerialization nur für dynamische Strukturen.

// Parsen einer API-Antwort
func parseUserResponse(data: Data) {
    do {
        guard let json = try JSONSerialization
            .jsonObject(with: data) as? [String: Any]
        else { return }

        guard let userId = json["id"] as? Int,
              let name = json["name"] as? String
        else {
            throw ParsingError.missingField
        }

        print("Benutzer: \(name) (ID: \(userId))")

    } catch let error as ParsingError {
        print("Parsing fehlgeschlagen: \(error)")
    } catch {
        print("Unerwarteter Fehler: \(error)")
    }
}

enum ParsingError: Error {
    case missingField
    case invalidType
}

Fehlerbehandlung

JSONSerialization wirft Fehler bei ungültigem JSON, Typkonflikten oder Überschreitung der Verschachtelungstiefe. Die Fehler gehören zum Typ CocoaError und enthalten einen Code, der das Problem beschreibt. Der Entwickler muss sie mit einer do-catch-Konstruktion behandeln, andernfalls stürzt die Anwendung ab. Die häufigsten Fehler sind: NSPropertyListReadCorruptError (ungültiges JSON) und NSPropertyListReadUnknownError. Jeder Fehlertyp erfordert seine eigene Behandlungsstrategie: Bei ungültigem Format die Daten erneut anfordern, bei Strukturkonflikten das Parsing-Modell aktualisieren.

Arten von Deserialisierungsfehlern

Ungültiges JSON — die häufigste Ursache für Fehler: Ein fehlendes Komma, ein zusätzliches Zeichen oder ein nicht maskiertes Anführungszeichen zerstört das gesamte Parsing. Die zweite Fehlerart ist die Nichtübereinstimmung mit der erwarteten Struktur: Zum Beispiel hat der Server ein Array anstelle eines Wörterbuchs zurückgegeben. JSONSerialization.fragmentsAllowed ermöglicht das Lesen von JSON, dessen Root kein Wörterbuch oder Array ist, sondern ein primitiver Wert. Der Entwickler kann auch auf einen Fehler der überschrittenen Verschachtelungstiefe stoßen, wenn JSON zu viele Hierarchieebenen enthält.

Lese- und Schreiboptionen

JSONSerialization bietet mehrere Optionen zur Konfiguration des Parsings. .mutableContainers gibt NSMutableDictionary und NSMutableArray anstelle von unveränderlichen Versionen zurück, was beim Ändern von Daten nach dem Parsen nützlich ist. .mutableLeaves macht Zeichenfolgenwerte veränderbar. .fragmentsAllowed erlaubt JSON, dessen Root kein Objekt oder Array ist, sondern eine Zeichenfolge oder Zahl — praktisch für einfache API-Antworten. Die Optionen .withoutEscapingSlashes und .sortedKeys sind für die Methode data(withJSONObject:options:) verfügbar und steuern die Formatierung von serialisiertem JSON. Optionen werden als Bitmaske übergeben, sodass mehrere Werte mit dem Operator | für eine flexible Parsing-Konfiguration kombiniert werden können.

// Behandlung verschiedener Fehlertypen
func safeParse(jsonData: Data) {
    do {
        let object = try JSONSerialization
            .jsonObject(with: jsonData,
                           options: .fragmentsAllowed)

        if let dictionary = object as? [String: Any] {
            print("Wörterbuch mit \(dictionary.count) Schlüsseln")
        } else if let array = object as? [Any] {
            print("Array mit \(array.count) Elementen")
        }

    } catch CocoaError.propertyListReadCorrupt {
        print("Beschädigte JSON-Daten")
    } catch let error as CocoaError {
        print("Cocoa-Fehler: \(error)")
    } catch {
        print("Unbekannter Fehler: \(error)")
    }
}

// Überprüfung der Objektgültigkeit vor der Serialisierung
let testObject: [String: Any] = ["key": "value", "nested": ["a": 1]]
if JSONSerialization.isValidJSONObject(testObject) {
    print("Gültiges JSON-Objekt")
}

Die Leistung von JSONSerialization hängt von der Datengröße und der Aufruffrequenz ab. Für ein einmaliges Parsen einer kleinen Serverantwort ist der Unterschied vernachlässigbar, aber bei der Verarbeitung von Dutzenden Megabyte JSON oder häufigen Aufrufen in Schleifen sollte der Overhead durch Typ-Casting berücksichtigt werden. JSONSerialization arbeitet synchron im aktuellen Thread. Für große Dokumente wird daher empfohlen, das Parsen über DispatchQueue.global() in eine Hintergrundwarteschlange zu verschieben. Alternativ können Sie InputStream für die Streaming-Verarbeitung verwenden, ohne die gesamte Datei in den Speicher zu laden, was für ressourcenbeschränkte Anwendungen entscheidend ist. Zum Schreiben von JSON in eine Datei oder einen Netzwerkstream ermöglicht die Methode writeJSONObject(_:to:options:error:) das direkte Senden serialisierter Daten an OutputStream ohne Erstellung eines zwischengeschalteten Data-Objekts, wodurch der Speicherverbrauch bei der Arbeit mit großen Dokumenten reduziert wird.