Comment désorganiser le JSON dynamique dans Go sans champs d'espace réservé génériques ?

Désorganisation du JSON dynamique basé sur une clé de type

Introduction

La désorganisation des données JSON dans une structure Go peut être une tâche simple. Cependant, lorsqu'il s'agit de documents JSON contenant des structures de données dynamiques, où le type d'un champ peut varier, le processus peut devenir plus complexe. Cet article explore une solution à ce défi sans introduire de champs d'espace réservé génériques.

Définition du problème

Considérez la spécification JSON suivante :

{
  "some_data": "foo",
  "dynamic_field": { "type": "A", "name": "Johnny" },
  "other_data": "bar"
}

{
  "some_data": "foo",
  "dynamic_field": { "type": "B", "address": "Somewhere" },
  "other_data": "bar"
}

Les deux documents JSON doivent être désorganisé dans la même structure Go :

type BigStruct struct {
  SomeData     string    `json:"some_data"`
  DynamicField Something `json:"dynamic_field"`
  OtherData    string    `json:"other_data"`
}

La question clé est : comment créer le Something taper et implémenter la logique de démarshalling ?

Solution : Utiliser une interface avec la méthode UnmarshalJSON personnalisée

La solution consiste à créer une interface pour le type Quelque chose :

type Something interface {
  GetType() string
}

Ensuite, définir des types de structures spécifiques qui implémentent l'interface Something :

type BaseDynamicType struct {
  Type string `json:"type"`
}

type DynamicTypeA struct {
  BaseDynamicType
  Name string `json:"name"`
}

type DynamicTypeB struct {
  BaseDynamicType
  Address string `json:"address"`
}

La méthode d'interface DynamicType permet aux données JSON d'être non organisé dans la structure appropriée :

func (d *DynamicType) UnmarshalJSON(data []byte) error {
    var typ struct {
        Type string `json:"type"`
    }
    if err := json.Unmarshal(data, &typ); err != nil {
        return err
    }
    switch typ.Type {
    case "A":
        d.Value = new(TypeA)
    case "B":
        d.Value = new(TypeB)
    }
    return json.Unmarshal(data, d.Value)
}

Cette méthode inspecte les données JSON et crée une instance de TypeA ou TypeB selon les besoins.

Implémentation d'UnmarshalJSON sur BigStruct

Enfin , implémentez la méthode UnmarshalJSON sur le BigStruct type :

func (b *BigStruct) UnmarshalJSON(data []byte) error {
    var tmp BigStruct // avoids infinite recursion
    return json.Unmarshal(data, &tmp)
}

Cette méthode utilise un type BigStruct temporaire pour éviter la récursion et permet au champ dynamique d'être désorganisé à l'aide du type DynamicType approprié en fonction du champ de type dans les données JSON.

Conclusion

Cette solution fournit un moyen propre et efficace de désassembler les données JSON dynamiques sans avoir besoin de champs d'espace réservé génériques supplémentaires. En utilisant une interface et en implémentant des méthodes UnmarshalJSON personnalisées, la structure Go peut s'adapter à la structure de données dynamique dans l'entrée JSON.

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!