Wie kann man JSON-Streams effizient dekodieren, ohne die gesamte Nutzlast in den Speicher zu laden?

JSON-Streams dekodieren, ohne die gesamte Nutzlast zu lesen

In diesem Szenario müssen wir über HTTP-Streaming empfangene JSON-Daten dekodieren, ohne sie zu laden gesamte Antwort im Gedächtnis speichern. Das Ziel besteht darin, einzelne JSON-Elemente (dargestellt als „große Objekte“ innerhalb eines Arrays) zu verarbeiten und sie beim Empfang an eine Nachrichtenwarteschlange zu senden.

Ereignisgesteuerte JSON-Analyse

Um dies zu erreichen, verwenden wir den json.Decoder und seine Methoden Decode() und Token(). Decode() kann verwendet werden, um einen einzelnen Wert zu entmarshalieren, während Token() es uns ermöglicht, nur das nächste Token im JSON-Stream zu analysieren, wodurch wir die Daten inkrementell verarbeiten können.

On-the- Fly-Token-Verarbeitung

Wir richten eine „Zustandsmaschine“ ein, um unsere Position innerhalb der JSON-Struktur zu verfolgen. Durch die Analyse jedes Tokens navigieren wir durch die Objekthierarchie und identifizieren das Array „items“ und seine großen Objektelemente.

Code-Implementierung

package main

import (
    "bufio"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "os"
)

// Helper error handler
func he(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

// Large object struct
type LargeObject struct {
    Id   string `json:"id"`
    Data string `json:"data"`
}

func main() {
    // JSON input for demonstration
    in := `{"somefield": "value", "otherfield": "othervalue", "items": [ {"id": "1", "data": "data1"}, {"id": "2", "data": "data2"}, {"id": "3", "data": "data3"}, {"id": "4", "data": "data4"}]}`

    dec := json.NewDecoder(strings.NewReader(in))

    // Expect an object
    t, err := dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != '{' {
        log.Fatal("Expected object")
    }

    // Read props
    for dec.More() {
        t, err = dec.Token()
        he(err)
        prop := t.(string)
        if t != "items" {
            var v interface{}
            he(dec.Decode(&v))
            fmt.Printf("Property '%s' = %v\n", prop, v)
            continue
        }

        // It's the "items". Expect an array
        t, err = dec.Token()
        he(err)
        if delim, ok := t.(json.Delim); !ok || delim != '[' {
            log.Fatal("Expected array")
        }
        // Read items (large objects)
        for dec.More() {
            // Read next item (large object)
            lo := LargeObject{}
            he(dec.Decode(&lo))
            fmt.Printf("Item: %+v\n", lo)
        }
        // Array closing delim
        t, err = dec.Token()
        he(err)
        if delim, ok := t.(json.Delim); !ok || delim != ']' {
            log.Fatal("Expected array closing")
        }
    }

    // Object closing delim
    t, err = dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != '}' {
        log.Fatal("Expected object closing")
    }
}

Beispielausgabe

Property 'somefield' = value
Property 'otherfield' = othervalue
Item: {Id:1 Data:data1}
Item: {Id:2 Data:data2}
Item: {Id:3 Data:data3}
Item: {Id:4 Data:data4}

Durch die Verwendung dieses ereignisgesteuerten Parsing-Ansatzes können wir große Mengen effektiv verarbeiten JSON antwortet inkrementell und vermeidet so einen übermäßigen Speicherverbrauch.

Das obige ist der detaillierte Inhalt vonWie kann man JSON-Streams effizient dekodieren, ohne die gesamte Nutzlast in den Speicher zu laden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!