Wie entmarshaliere ich dynamisches JSON in Go basierend auf einem Typschlüssel ohne generische Felder?

Unmarshaling von dynamischem JSON basierend auf einem Typschlüssel ohne Einführung generischer Felder

Viele strukturierte JSON-Daten erfordern das Unmarshaling in Go-Strukturen, die oft verschachtelte Felder enthalten mit unterschiedlichen Datentypen. Wenn der Datentyp eines verschachtelten Felds je nach Typschlüssel im JSON variiert, können herkömmliche Methoden zum Unmarshalling mithilfe benutzerdefinierter Felder zu unnötigem Boilerplate-Code führen.

In diesem Zusammenhang betrachten wir die folgende JSON-Spezifikation:

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

und

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

Diese beiden JSON-Dokumente sollten im selben Go entmarshallt werden struct:

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

Die Herausforderung besteht darin, den Typ „Something“ zu definieren, der dynamische Daten basierend auf dem Schlüssel „type“ im Objekt „dynamic_field“ aufnehmen kann.

Um die Notwendigkeit zu vermeiden Für ein explizites „generisches“ Feld (z. B. Wert, Daten) können wir die Leistungsfähigkeit der Typeinbettung und von Schnittstellen nutzen.

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

type DynamicType struct {
  Value interface{}
}

Innerhalb der „DynamicType“, das „Value“-Feld kann jeden Datentyp enthalten, basierend auf dem „Type“-Schlüssel im JSON. Um das ordnungsgemäße Unmarshalling zu erleichtern, implementieren wir die UnmarshalJSON-Methode für „DynamicType“:

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)
}

Wir definieren spezifische Typen für verschiedene Datentypen:

type TypeA struct {
    Name string `json:"name"`
}

type TypeB struct {
    Address string `json:"address"`
}

Mit diesem Ansatz können wir das Entpacken Sie die JSON-Dokumente, ohne dass ein zusätzliches generisches Feld erforderlich ist, sodass wir eine saubere und erweiterbare Datenstruktur beibehalten können.

Das obige ist der detaillierte Inhalt vonWie entmarshaliere ich dynamisches JSON in Go basierend auf einem Typschlüssel ohne generische Felder?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!