Wie kann ich die Typzusicherung nach dem Unmarshalling von JSON in interface{} in Go effizient handhaben?

Unmarshalling into Interface{} for Type Assertion in Golang

In diesem Szenario werden JSON-Strings über RabbitMQ übertragen. Diese Zeichenfolgen stellen Instanzen zweier verschiedener Strukturen dar: Somthing1 und Somthing2. Das Ziel besteht darin, die JSON-Strings wieder in ihre jeweiligen Strukturen zu entmarshallieren und Typzusicherungen auszuführen.

Das Problem

Auf den ersten Blick scheint es, als ob das Unmarshalling in eine Schnittstelle{} und das anschließende Anwenden von Typzusicherungen erforderlich wäre sollte reichen. Beim Unmarshalling ist die Eingabevariable jedoch vom Typ „map[string]interface{}“. Dies ist nicht wie erwartet und Versuche, diesen Typ einzuschalten oder ihn den gewünschten Strukturen neu zuzuweisen, schlagen fehl.

Die Lösung

Die JSON-Bibliothek in Golang entmarshallt in Standardtypen wie bool, float64 und map[string]interface{}. Um die gewünschten Strukturen zu erhalten, müssen Sie das Unmarshalieren direkt in sie durchführen oder manuell aus der Map[string]-Schnittstelle{} konvertieren.

Direktes Unmarshalieren verwenden

Der bevorzugte Ansatz ist das direkte Unmarshalieren in die Strukturen:

func typeAssert(msg string) {
    var job Somthing1
    json.Unmarshal([]byte(msg), &job)

    // ...

    var stats Somthing2
    json.Unmarshal([]byte(msg), &stats)

    // ...
}

Verwenden einer Unpacker-Struktur

If Ein direktes Unmarshalling ist nicht möglich. Sie können eine Unpacker-Struktur verwenden, um das Unmarshalling zu handhaben und eine Schnittstelle für den Zugriff auf die Daten bereitzustellen:

type Unpacker struct {
    Data       interface{}
}

func (u *Unpacker) UnmarshalJSON(b []byte) error {
    // Attempt to unmarshal into both types
    smth1 := &Something1{}
    err := json.Unmarshal(b, smth1)

    if err == nil && smth1.Thing != "" {
        u.Data = smth1
        return nil
    }

    smth2 := &Something2{}
    err = json.Unmarshal(b, smth2)
    if err != nil {
        return err
    }

    u.Data = smth2
    return nil
}

Dann können Sie den Unpacker verwenden, um auf die entmarshallten Daten zuzugreifen:

func typeAssert(msg string) {
    unpacker := &Unpacker{}
    json.Unmarshal([]byte(msg), unpacker)

    switch v := unpacker.Data.(type) {
    case Something1:
        // ...

    case Something2:
        // ...

    default:
        // Handle unknown type
    }
}

Das obige ist der detaillierte Inhalt vonWie kann ich die Typzusicherung nach dem Unmarshalling von JSON in interface{} in Go effizient handhaben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!