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

一分耕耘，一分收获！既然打开了这篇文章《如何简化深度嵌套 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))
}

正如您从上面看到的，它包含的结构没有多大意义，因为它们更像是嵌套数据的占位符。那么我们如何让它更加优化。由于所有数据都在最后一个结构中得到处理。应采用哪种数据解组方法，因为响应将采用相同的格式，并且希望使用最后一个结构。 关于该方法的任何想法。 另外，如何创建一个通用结构，因为我使用多个 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"`
}

解决方案

如果除了编组/解组之外不需要任何包装类型，则可以匿名定义它们：

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))
}

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

为了轻松使用它，您可以创建辅助函数并使用它们：

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
}

但除此之外，你无法真正简化其他事情。

因此编组 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

今天关于《如何简化深度嵌套 JSON 的封送处理》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！