Comment « json.Decoder » de Go peut-il décoder efficacement les réponses JSON volumineuses ?

Décodage en continu de grandes réponses JSON avec l'analyseur événementiel de Go

Dans Go, le décodage du JSON à partir des points de terminaison de l'API se faisait traditionnellement en chargeant l'intégralité de la réponse en mémoire, comme démontré dans les approches passées. Cependant, la gestion des réponses JSON volumineuses, en particulier celles contenant des tableaux de longueur significative, nécessite une méthode plus efficace.

Pour éviter de surcharger la mémoire, cet article explore l'utilisation de json.Decoder de Go et ses capacités d'analyse basée sur les événements pour gérer efficacement les flux JSON.

Le décodage de flux JSON avec json.Decoder

json.Decoder fournit un moyen pour décoder les données JSON telles qu'elles sont toujours diffusées, sans consommer la totalité du flux. Cela permet le traitement de grandes réponses JSON de manière fragmentaire.

Implémentation d'un analyseur JSON piloté par événements

Pour implémenter un décodeur JSON en streaming, nous utilisons Decoder.Token() pour récupérer des réponses individuelles. jetons dans le flux JSON. En interprétant ces jetons, nous pouvons construire une machine à états qui suit notre position dans la structure JSON.

Traitement d'un grand exemple JSON

Considérez la structure JSON suivante :

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

Notre objectif est de traiter ce flux JSON, en capturant chaque gros objet (représenté par le tableau "items") sans avoir besoin de décoder l'intégralité structure.

Exemple d'implémentation

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 { ... }

Sortie

L'exemple fourni produira la sortie suivante, démontrant le traitement réussi des objets volumineux à partir du flux JSON :

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

Conclusion

En utilisant l'analyse basée sur les événements de json.Decoder Grâce à ces capacités, les développeurs peuvent gérer efficacement les réponses JSON volumineuses, évitant ainsi les surcharges de mémoire et permettant le traitement en temps réel des données en streaming. L'implémentation présentée sert de guide pratique pour implémenter un tel décodeur dans Go.

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!