如何简化深度嵌套JSON的封送

我有一个JSON，其中包含一些静态和动态数据。下面是一个JSON示例

{
  "request": {  /*Static data start */
    "data": {
      "object": { /*Static data ends here*/
        "user": { /*Dynamic data start here */
          "userid": "andmmdn",
          "ipaddr": "1.1.1.1",
          "noofusers": "100",
          "qos": "34",
          "id": "kldjflkdfjlkdjfkld",
          "domain": "xyz.com" /*Dynamic data ends here */
        } 
      }
    }
  }
}

下面是可以创建此JSON的代码

package main

import (
    "fmt"
    "encoding/json"
)
//ReqJSON struct
type ReqJSON struct {
    Request Request `json:"request"`
}
//Request struct
type Request struct {
    Data Data `json:"data"` 
}
//Data struct
type Data struct {
    Object Object `json:"object"`
}
//Object struct
type Object struct {
    User User `json:"user"`
}
//User struct
type User struct {
    UserID string `json:"userid"`
    IPAddr string `json:"ipaddr"`
    Noofusers string `json:"noofusers"`
    Qos string `json:"qos"`
    ID string `json:"id"`
    Domain string `json:"domain"`
}
func main() {
    test := ReqJSON {
        Request{
            Data: Data{
                Object: Object{
                    User: User{
                        UserID: "andmmdn",
                        IPAddr: "1.1.1.1",
                        Noofusers: "100",
                        Qos: "34",
                        ID: "kldjflkdfjlkdjfkld",
                        Domain: "xyz.com",
                    },  
                },  
            },
        },
    }
    jsonEncode, _ := json.Marshal(test)
    jsonIdent, _ := json.MarshalIndent(&test, "", "\t")
    fmt.Println(string(jsonEncode))
    fmt.Println(string(jsonIdent))
}

从上面可以看到，它包含struct，这没有多大意义，因为它们更像是嵌套数据的占位符。因此，我们如何使其更加优化。因为所有数据都在最后一个结构中处理。由于响应将采用相同的格式，并且希望使用最后一个结构来处理相同的响应，因此应采用何种方法来解组数据。 对这个方法有什么想法吗。 另外，下面是一个例子，说明如何使一个通用结构成为使用相同结构的多个API

//ReqJSON for populating data
type ReqJSON struct {
    Request struct {
        Data struct {
            Object struct {
                Auth Auth `json:"auth"`
            } `json:"object"`
        } `json:"data"`
    } `json:"request"`
}
//ReqJSON for populating data
type ReqJSON struct {
    Request struct {
        Data struct {
            Object struct {
                Error Error `json:"error"`
            } `json:"object"`
        } `json:"data"`
    } `json:"request"`
}

---

听起来不错。解决方案有点冗长/冗余，但您必须处理的数据格式也是如此

要轻松使用该功能，您可以创建帮助器函数并使用它们：

func wrap(u User) *ReqJSON {
    return &ReqJSON{Request: Request{Data: Data{Object: Object{User: u}}}}
}

func unwrap(r *ReqJSON) User {
    return r.Request.Data.Object.User
}

但除此之外，你不能真正简化其他事情

因此，封送

用户类似于：

var u User
data, err := json.Marshal(wrap(u))

解组是：

var r *ReqJSON
err := json.Unmarshal(data, &r)
// Check error

u := unwrap(r) // Here we have the user

您无法消除复杂性，但可能会将部分复杂性隐藏在自定义封送拆收器中：

type Request struct {
    UserID    string `json:"userid"`
    IPAddr    string `json:"ipaddr"`
    Noofusers string `json:"noofusers"`
    Qos       string `json:"qos"`
    ID        string `json:"id"`
    Domain    string `json:"domain"`
}

func (r *Request) MarshalJSON() ([]byte, error) {
    type request struct {
        Data struct {
            Object struct {
                User struct {
                    Request
                } `json:"user"`
            } `json:"object"`
        } `json:"data"`
    }
    structure := request{Data: data{Object: object{User: user{r}}}}
    return json.Marshal(structure)    
}

如果需要，同样的方法也可以反过来用于
解组JSON
。
如果除了封送/解组外，您不需要任何包装类型，则可以匿名定义它们：

type ReqJSON struct {
    Request struct {
        Data struct {
            Object struct {
                User User `json:"user"`
            } `json:"object"`
        } `json:"data"`
    } `json:"request"`
}

type User struct {
    UserID string `json:"userid"`
    IPAddr string `json:"ipaddr"`
    Noofusers string `json:"noofusers"`
    Qos string `json:"qos"`
    ID string `json:"id"`
    Domain string `json:"domain"`
}

根据icza的回答，您可以将访问器方法添加到
ReqJSON
：

func (j *ReqJSON) User() User     { return j.Request.Data.Object.User }
func (j *ReqJSON) SetUser(u User) { j.Request.Data.Object.User = u }

func main() {
    var j ReqJSON
    j.SetUser(User{
            UserID:    "_id",
            IPAddr:    "1.1.1.1",
            Noofusers: "100",
            Qos:       "34",
            ID:        "kldjflkdfjlkdjfkld",
            Domain:    "xyz.com",
    })

    b, err := json.MarshalIndent(j, "", "  ")
    fmt.Println(err, string(b))
}

如果包装类型没有在其他地方使用，为了简洁起见，可以匿名定义它们：@Peter Right，将其作为答案发布。