Wie kann Gos „json.Decoder' große JSON-Antworten effizient streamen und dekodieren?

Stream-Dekodierung großer JSON-Antworten mit dem ereignisgesteuerten Parser von Go

In Go erfolgte die Dekodierung von JSON von API-Endpunkten traditionell durch das Laden der gesamten Antwort in den Speicher in der Vergangenheit gezeigte Ansätze. Die Verarbeitung großer JSON-Antworten, insbesondere solcher, die Arrays mit erheblicher Länge enthalten, erfordert jedoch eine effizientere Methode.

Um eine Speicherüberlastung zu vermeiden, untersucht dieser Artikel die Verwendung von Gos json.Decoder und seine ereignisgesteuerten Parsing-Funktionen Behandeln Sie JSON-Streams effektiv.

JSON-Stream-Dekodierung mit json.Decoder

json.Decoder bietet eine bedeutet, JSON-Daten zu dekodieren, während sie noch einströmen, ohne den gesamten Stream zu verbrauchen. Dies ermöglicht die schrittweise Verarbeitung großer JSON-Antworten.

Implementierung eines ereignisgesteuerten JSON-Parsers

Um einen Streaming-JSON-Decoder zu implementieren, verwenden wir Decoder.Token(), um einzelne Antworten abzurufen Token im JSON-Stream. Durch die Interpretation dieser Token können wir eine Zustandsmaschine erstellen, die unsere Position innerhalb der JSON-Struktur verfolgt.

Verarbeitung eines großen JSON-Beispiels

Betrachten Sie die folgende JSON-Struktur:

{
    "somefield": "value",
    "otherfield": "othervalue",
    "items": [
        { "id": "1", "data": "data1" },
        { "id": "2", "data": "data2" },
        ...
    ]
}

Unser Ziel ist es, diesen JSON-Stream zu verarbeiten und jedes große Objekt (dargestellt durch das Array „items“) zu erfassen, ohne dass das Ganze dekodiert werden muss Struktur.

Implementierungsbeispiel

dec := json.NewDecoder(res.Body) // or strings.NewReader(jsonStream) for demonstration purposes

// Parse the outer JSON structure
_, err := dec.Token() // Expecting an object
if err != nil { ... }

// Iterate over properties
for dec.More() {
    prop, err := dec.Token().(string) // Property name
    if err != nil { ... }

    if prop != "items" {
        var v interface{} // Decode property value
        if err := dec.Decode(&v); err != nil { ... }
        log.Printf("Property '%s' = %v", prop, v)
        continue
    }

    // Parse items array
    _, err := dec.Token() // Expecting array
    if err != nil { ... }

    // Read and process items
    for dec.More() {
        lo := LargeObject{} // Initialize large object struct
        if err := dec.Decode(&lo); err != nil { ... }
        fmt.Printf("Item: %+v\n", lo)
    }

    _, err := dec.Token() // Expecting array closing
    if err != nil { ... }
}

// Parse outer object closing
_, err := dec.Token() // Expecting object closing
if err != nil { ... }

Ausgabe

Das bereitgestellte Beispiel erzeugt die folgende Ausgabe und demonstriert die erfolgreiche Verarbeitung großer Objekte aus dem JSON-Stream:

Property 'somefield' = value
Property 'otherfield' = othervalue
Item: {Id:1 Data:data1}
Item: {Id:2 Data:data2}
...

Fazit

Durch die Verwendung der ereignisgesteuerten Analyse von json.Decoder Mit diesen Funktionen können Entwickler große JSON-Antworten effizient verarbeiten, Speicherüberlastungen vermeiden und die Echtzeitverarbeitung von Streaming-Daten ermöglichen. Die vorgestellte Implementierung dient als praktischer Leitfaden zur Implementierung eines solchen Decoders in Go.

Das obige ist der detaillierte Inhalt vonWie kann Gos „json.Decoder' große JSON-Antworten effizient streamen und dekodieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!