Question

我有一个包含一些静态和动态数据的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"`
}

Answer 1

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

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

Answer 2

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

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

public abstract class ProjectAttribute
{
    public int ID { get; set; }
    public string Title { get; set; }
}
public class Attribute_HW : ProjectAttribute
{
    public static List<Attribute_HW> Hardware_Attributes { get; private set; }
    static Attribute_HW() 
    {
        // Read Attributes from external DataSource to List 'Hardware_Attributes'
    }

    // Some Attribute specific logic but no more fields
}
// Followed by 4 more Attribute Classes

public class Project
{
    public ICollection<Attribute_HW> AttributesHardware { get; set; }
    public ICollection<Attribute_SW> AttributesSoftware { get; set; }
    // 3 more Attribute Collections
}

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

封送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))

Answer 3

您无法消除复杂性，但是可能会将其中一些隐藏在自定义的Marshaler中：

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

如果需要，UnmarshalJSON可以采用相同的方法。

如何简化深层JSON的封送处理

3 个答案: