Comment l'analyse basée sur les événements peut-elle améliorer l'efficacité du décodage des flux JSON pour les réponses JSON volumineuses ?

Décodage de flux JSON avec analyse basée sur les événements

Lorsque vous traitez des réponses JSON volumineuses contenant de grands tableaux, le décodage de l'intégralité de la réponse en mémoire peut consomment des ressources importantes et ont un impact sur les performances. Pour atténuer ce problème, nous pouvons utiliser l'analyse basée sur les événements avec json.Decoder pour diviser le flux JSON en morceaux plus petits et les traiter de manière incrémentielle.

Analyse basée sur les événements avec Decoder.Token()

Le json.Decoder fournit la méthode Token(), qui nous permet d'analyser uniquement le jeton suivant dans le flux JSON sans consommant la totalité de l'entrée. Cela nous permet d'analyser et de traiter le flux JSON de manière incrémentielle, objet par objet.

Traitement du flux JSON

Pour traiter le flux JSON, nous pouvons utiliser une machine à états qui suit la structure de l'objet JSON et gère les jetons en conséquence. Les étapes suivantes décrivent le processus :

1. Lire le délimiteur d'objet d'ouverture : Nous nous attendons à ce que la réponse JSON commence par une accolade ouvrante ({), indiquant le début d'un objet. .
2. Analyser les propriétés et les valeurs : Au fur et à mesure que nous parcourons le flux JSON, nous rencontrons des noms de propriétés (clés) et leurs valeurs correspondantes. Nous pouvons décoder ces propriétés et valeurs en utilisant Decoder.Decode().
3. Handle Arrays : Lorsque nous rencontrons la clé du tableau ("éléments" dans votre exemple), nous attendons un délimiteur de tableau ( [). Nous parcourons ensuite les éléments du tableau, analysant et traitant chaque élément.
4. Traiter les éléments individuels : Pour chaque élément (gros objet), nous le décodons en un type structuré (par exemple, LargeObject) en utilisant Decoder.Decode().
5. Lire les délimiteurs de fermeture : Après avoir traité le tableau, nous attendons un carré de fermeture parenthèse (]). De même, nous nous attendons à ce qu'une accolade fermante (}) indique la fin de l'objet JSON.

Gestion des erreurs

La gestion des erreurs tout au long du processus est cruciale pour garantir une exécution correcte et cohérente. Une fonction de gestionnaire d'erreurs personnalisée peut simplifier la gestion des erreurs et fournir des messages d'erreur clairs.

Exemple de mise en œuvre

Voici un exemple de mise en œuvre basé sur le format JSON d'entrée fourni :

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

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

// Simplified error handling function
func he(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    // Example JSON stream
    jsonStream := `{
        "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(jsonStream))

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

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

        // Read "items" array
        t, err = dec.Token()
        he(err)
        if delim, ok := t.(json.Delim); !ok || delim != '[' {
            log.Fatal("Expected array")
        }

        // Read and process items
        for dec.More() {
            lo := LargeObject{}
            he(dec.Decode(&lo))
            fmt.Printf("Item: %+v\n", lo)
        }

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

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

Notez que cette implémentation attend un objet JSON valide. La gestion des erreurs peut être étendue pour couvrir les entrées JSON mal formées ou incomplètes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!