Wie entmarshaliere ich komplexes, selbstreferenzielles JSON in Go?

Unmarshaling von JSON mit selbstreferenziellen Strukturelementen

Betrachten Sie die folgende JSON-Zeichenfolge mit einer verschachtelten Struktur:

[{
    "db": {
        "url": "mongodb://localhost",
        "port": "27000",
        "uname": "",
        "pass": "",
        "authdb": "",
        "replicas": [
            {
                "rs01": {
                    "url":"mongodb://localhost",
                    "port": "27001",
                    "uname": "",
                    "pass": "",
                    "authdb": ""
                }
            },
            {
                "rs02": {
                    "url":"mongodb://localhost",
                    "port": "27002",
                    "uname": "",
                    "pass": "",
                    "authdb": ""
                }
            }
        ]
    }
}]

Um diesen JSON in einer Go-Struktur darzustellen, definieren wir Folgendes struct:

type DBS struct {
    URL      string   `json:"url"`
    Port     string   `json:"port"`
    Uname    string   `json:"uname"`
    Pass     string   `json:"pass"`
    Authdb   string   `json:"authdb"`
    Replicas []DBS    `json:"replicas"`
}

Der Versuch, die JSON-Zeichenfolge in ein Slice dieser Struktur zu entmarshalieren, führt jedoch zu einem leeren Slice.

Das Problem liegt in der Tatsache, dass die JSON-Eingabe keine ist Teil der DBS-Strukturen. Stattdessen enthält es einen anderen JSON-Objekt-Wrapper und der Wert DBS gehört zur Eigenschaft „db“. Darüber hinaus enthält die Eigenschaft „replicas“ ein JSON-Array mit Objekten mit unterschiedlichen Schlüsseln, die auch durch DBS-Strukturen dargestellt werden können.

Um dieses JSON vollständig zu modellieren, benötigen wir einen dynamischen Typ, beispielsweise eine Karte. Der von uns benötigte Typ ist []map[string]DBS, der einen Teil der Karten darstellt. Der Kartenschlüssel kann einen beliebigen Eigenschaftsnamen modellieren, und der Wert ist ein JSON-Objekt, das von der DBS-Struktur modelliert wird.

Das folgende Beispiel zeigt, wie die JSON-Eingabe mit diesem Typ vollständig analysiert wird:

import (
    "encoding/json"
    "fmt"
)

type DBS struct {
    URL      string           `json:"url"`
    Port     string           `json:"port"`
    Uname    string           `json:"uname"`
    Pass     string           `json:"pass"`
    Authdb   string           `json:"authdb"`
    Replicas []map[string]DBS `json:"replicas"`
}

func main() {
    var dbs []map[string]DBS
    if err := json.Unmarshal([]byte(src), &dbs); err != nil {
        panic(err)
    }
    fmt.Printf("%+v", dbs)
}

Ausgabe:

[map[db:{URL:mongodb://localhost Port:27000 Uname: Pass: Authdb: Replicas:[map[rs01:{URL:mongodb://localhost Port:27001 Uname: Pass: Authdb: Replicas:[]}] map[rs02:{URL:mongodb://localhost Port:27002 Uname: Pass: Authdb: Replicas:[]}]]}]]

Beachten Sie, dass die erste Ebene immer „db“ ist, die weiter modelliert werden kann und wir zu Zeigern für wechseln können verbesserte Lesbarkeit.

Indem wir die Verschachtelung und Struktur der JSON-Eingabe verstehen, können wir sie effektiv in eine benutzerdefinierte Struktur entpacken, die die Daten genau darstellt.

Das obige ist der detaillierte Inhalt vonWie entmarshaliere ich komplexes, selbstreferenzielles JSON in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!