Wie kann benutzerdefiniertes Marshalling in Go Embedded-Strukturen beibehalten werden?

Benutzerdefiniertes Marshalling für eingebettete Strukturen beibehalten

In Go ist das Einbetten einer Struktur in eine andere eine übliche Methode, um Funktionalität zu erben. Wenn die eingebettete Struktur jedoch über eine benutzerdefinierte MarshalJSON()-Methode verfügt, können Probleme auftreten. In diesem Artikel wird eine Lösung für diese Herausforderung untersucht, die sicherstellt, dass die äußere Struktur ihre Felder normal rangieren kann und gleichzeitig weiterhin das benutzerdefinierte Marshalling der eingebetteten Struktur nutzt.

Berücksichtigen Sie die folgenden Strukturen:

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

type Employee struct {
    *Person
    JobRole string `json:"jobRole"`
}

Normalerweise würde das Marshallen eines Mitarbeiters in JSON die erwartete Ausgabe erzeugen:

p := Person{"Bob"}
e := Employee{&p, "Sales"}
output, _ := json.Marshal(e)
fmt.Printf("%s\n", string(output))
// Output: {"name":"Bob","jobRole":"Sales"}

Allerdings würde die Einführung eines benutzerdefinierten MarshalJSON() -Methode für die eingebettete Person-Struktur ändert dieses Verhalten:

func (p *Person) MarshalJSON() ([]byte, error) {
    return json.Marshal(struct{ Name string `json:"name"` }{Name: strings.ToUpper(p.Name)})
}

Das Marshalling des Mitarbeiters erzeugt nun nur noch den Namen in Großbuchstaben:

output, _ := json.Marshal(e)
fmt.Printf("%s\n", string(output))
// Output: {"name":"BOB"}

Um dieses Problem zu beheben, könnte man versuchen, einen MarshalJSON hinzuzufügen ()-Methode zur äußeren Employee-Struktur hinzufügen. Dieser Ansatz erfordert jedoch Kenntnisse über das benutzerdefinierte Marshalling des eingebetteten Typs, was möglicherweise nicht immer praktikabel ist.

Eine allgemeinere Lösung besteht darin, MarshalJSON() direkt auf dem äußeren Typ zu implementieren:

// Note: not on Person
func (e *Employee) MarshalJSON() ([]byte, error) {
    inner, err := json.MarshalIndent((*e.Person).(*Person), "", "    ")
    if err != nil {
        return nil, err
    }

    b := []byte(strings.Replace(string(inner), "}", "}", -1))
    b = append(b, []byte(`,"jobRole":"`+e.JobRole+`"}`)...)

    return b, nil
}

Dieser Ansatz ruft die MarshalJSON()-Methode der eingebetteten Struktur auf, konvertiert das Ergebnis in eine Karte und fügt die Felder der äußeren Struktur hinzu, um die gewünschte JSON-Ausgabe zu erzeugen. Beachten Sie, dass dadurch das benutzerdefinierte Marshalling der eingebetteten Struktur nicht manipuliert wird.

Alternativ kann man einen reflexionsbasierten Ansatz verwenden:

func (e *Employee) MarshalJSON() ([]byte, error) {
    v := reflect.ValueOf(e).Elem()
    vf := v.FieldByName("Person")
    tmp, err := json.MarshalIndent(vf.Interface(), "", "    ")
    if err != nil {
        return nil, err
    }

    return []byte(strings.Replace(string(tmp), "}", `,"jobRole":"`+e.JobRole+`"}`, -1)), nil
}

Diese Methode verwendet Reflektion, um auf den Wert und das Feld der eingebetteten Struktur zuzugreifen , wodurch benutzerdefiniertes Marshalling ermöglicht wird, ohne auf Strukturkenntnisse angewiesen zu sein.

Durch die Implementierung von MarshalJSON() auf den äußeren Typ stellt dieser Ansatz sicher, dass sowohl der eingebettete als auch der Die Felder der äußeren Struktur werden korrekt gemarshallt, wobei die gewünschte Ausgabe erhalten bleibt.

Das obige ist der detaillierte Inhalt vonWie kann benutzerdefiniertes Marshalling in Go Embedded-Strukturen beibehalten werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!