Wie entmarshaliere ich einen selbstreferenziellen JSON-String in Go mit einem dynamischen Typ?

Unmarshalling eines JSON-Strings zu einer Struktur mit einem selbstreferenziellen Element

In Go, Unmarshalling eines JSON-Strings zu einer Struktur mit einem selbstreferenziellen Element Referenzelement kann eine Herausforderung sein. Sehen wir uns ein konkretes Beispiel und eine Lösung an, um dieses Problem effektiv anzugehen.

JSON-Eingabe und Strukturdefinition

Betrachten Sie die folgende JSON-Eingabe:

[{
    "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": ""
                }
            }
        ]
    }
}]

Und die entsprechende Go-Struktur:

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"`
}

Unmarshal-Funktion und Ausgabe

Die bereitgestellte Funktion „loadConfigs()“ versucht, die JSON-Zeichenfolge in ein Segment von DBS-Strukturen zu entmarshalieren:

func loadConfigs() []DBS {
    var config []DBS
    raw, err := ioutil.ReadFile("./config.json")
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(1)
    }

    json.Unmarshal(raw, &config)
    return config
}

Dies führt jedoch zu einem leeren Segment, [ ]DBS{, da die JSON-Eingabe kein Slice von DBS-Strukturen ist, sondern ein JSON-Objekt-Wrapper, der ein Array von enthält Objekte.

Lösung: Zuordnung zu einem dynamischen Typ

Um die JSON-Eingabe vollständig zu beschreiben, ist ein dynamischer Typ wie eine Karte erforderlich. Die aktualisierte Typdefinition lautet:

type DBSReplicated struct {
    DB *DBS `json:"db"`
}

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"`
}

Mit diesem neuen Typ können wir die JSON-Eingabe genau analysieren:

var dbs []*DBReplicated
if err := json.Unmarshal([]byte(src), &dbs); err != nil {
    panic(err)
}

db := dbs[0].DB
fmt.Printf("%+v\n", db)
for _, dbs := range db.Replicas {
    for name, replica := range dbs {
        fmt.Printf("%s: %+v\n", name, replica)
    }
}

Ausgabe

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

Schlüssel Punkte

• Verwenden Sie einen Kartentyp, um dynamische JSON-Eingaben zu modellieren.
• Achten Sie auf die richtige Syntax für JSON-Tag-Eigenschaftsnamen.
• Erwägen Sie die Verwendung von Zeigern in der Struktur, um verschachtelte Strukturen zu ermöglichen.

Das obige ist der detaillierte Inhalt vonWie entmarshaliere ich einen selbstreferenziellen JSON-String in Go mit einem dynamischen Typ?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!