How to Unmarshal Nested JSON with Structurally Similar Elements in Go?

Unmarshalling JSON with Nesting and Structural Similarity

When dealing with complex JSON structures, it is common to encounter scenarios where one element of a struct is of the same type as the struct itself. This can pose challenges during the unmarshalling process.

In this specific case, we are given a JSON string that represents an array of database configurations. Each database configuration contains various attributes, including a list of replicas. Each replica is also a JSON object with attributes similar to the database configuration.

To unmarshal this JSON string, we need a data structure that can accommodate the nesting and structural similarity.

Modeling the Nested Structure with Dynamic Types

Since the JSON input is not a slice of DBS structs, we need a more flexible data type to capture its structure. A map[string]interface{} is an excellent option because it can represent key-value pairs with dynamic values.

Example:

type DBS struct {
    URL      string
    Port     string
    Uname    string
    Pass     string
    Authdb   string
    Replicas []DBS
}

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

    var config []map[string]interface{}
    json.Unmarshal(raw, &config)

    for _, db := range config {
        d, ok := db["db"]
        if !ok {
            // Handle the case where "db" is missing
        }

        db := d.(map[string]interface{})
        url := db["url"].(string)
        port := db["port"].(string)

        var replicas []DBS
        for _, replica := range db["replicas"] {
            replicas = append(replicas, mapToDBS(replica))
        }

        // ... Other operations
    }
}

Using a Dynamic Type to Parse the JSON

In this example, the config variable is a slice of maps, which allows it to hold the database configurations as key-value pairs.

For each database configuration, we retrieve the "db" sub-object and cast it to a map[string]interface{}. This allows us to access the individual attributes such as "url" and "port".

The "replicas" attribute is handled similarly. Each replica is a JSON object, so it can be converted into a DBS struct using the mapToDBS() function.

By leveraging the flexibility of dynamic types, we can effectively unmarshal the JSON string and parse its nested structure.

The above is the detailed content of How to Unmarshal Nested JSON with Structurally Similar Elements in Go?. For more information, please follow other related articles on the PHP Chinese website!