有没有更简单的方法可以使用Golang JSON编码在JSON对象上添加图层？

问题描述：

The out of the box JSON encoding in Go is really nice, but I need to get the output to match a certain format by adding a layer. I've figured out a way, but was hoping that there would be an easier way than the way I'm doing it.

Below is an example of how I'm doing it.

import (
  "bytes"
  "encoding/json"
  "encoding/xml"
  "fmt"
)
type Query struct {
    XMLName xml.Name      `xml:"http://marklogic.com/appservices/search query" json:"-"`
    Format  int           `xml:"-" json:"-"`
    Queries []interface{} `xml:",any" json:"queries"`
}
type TermQuery struct {
    XMLName xml.Name `xml:"http://marklogic.com/appservices/search term-query" json:"-"`
    Terms   []string `xml:"http://marklogic.com/appservices/search text" json:"text"`
    Weight  float64  `xml:"http://marklogic.com/appservices/search weight,omitempty" json:"weight,omitempty"`
}
// use fakeQuery to avoid an infinite loop
type fakeQuery Query

//MarshalJSON for Query struct in a special way to add wraping {"query":...}
func (q Query) MarshalJSON() ([]byte, error) {
    return wrapJSON(`query`, fakeQuery(q))
}
// use fakeTermQuery to avoid an infinite loop
type fakeTermQuery TermQuery

//MarshalJSON for TermQuery struct in a special way to add wraping {"term-query":...}
func (q TermQuery) MarshalJSON() ([]byte, error) {
    return wrapJSON(`term-query`, fakeTermQuery(q))
}

func wrapJSON(name string, item interface{}) ([]byte, error) {
    var buffer bytes.Buffer
    b, err := json.Marshal(item)
    buffer.Write([]byte(`{"`))
    buffer.Write([]byte(name))
    buffer.Write([]byte(`":`))
    buffer.Write(b)
    buffer.Write([]byte(`}`))
    return buffer.Bytes(), err
}

I have a lot of defined structures that I would need to do this to, so I'm hoping for a better solution that won't leave me with with 100+ lines of code to just add a wrapper around the JSON object. Ideally I would like something that could peak at the XML element name defined for the XML encoder and use that to wrap the JSON.

In my case I'm using the MarshalJSON functions because these structures can be nested. If it helps I always know that the Query structure is the root structure.

Go中开箱即用的JSON编码确实很棒，但是我需要获取输出以匹配特定的通过添加图层来格式化。我已经找到了一种方法，但是希望有比我正在做的方法更简单的方法。 p>

下面是我如何做的一个示例。 p>

  import（
“字节” 
“ encoding / json” 
“ encoding / xml” 
“ fmt” 
）
type查询结构{
  XMLName xml.Name`xml：“ http://marklogic.com/appservices/search query” json：“-”`
 Format int`xml：“-” json：“-”`
查询[]接口{  }`xml：“，any” json：“ queries”`
} 
type TermQuery结构{
 XMLName xml.Name`xml：“ http://marklogic.com/appservices/search term-query” json：“  -“`
条款[]字符串`xml：” http://marklogic.com/appservices/search text“ json：” text“`
重量float64`xml：” http://marklogic.com/appservices/ 搜索weight，omitempty“ json：” weight，omitempty“`
} 
 ///使用fakeQuery避免无限循环
键入fakeQuery Query 
 
 // MarshalJSON以特殊的方式添加查询{ 查询“：...} 
func（q查询）MarshalJSON（）（[] byte，error）{
返回wrapJSON（`query`，fakeQu  ery（q））
} 
 //使用fakeTermQuery来避免无限循环
type fakeTermQuery TermQuery 
 
 // MarshalJSON for TermQuery结构以一种特殊的方式添加包装{{term-query“：...  } 
func（q TermQuery）MarshalJSON（）（[] byte，error）{
 return wrapJSON（`term-query`，fakeTermQuery（q））
} 
 
func wrapJSON（name string，item interface {}  ）（[] byte，error）{
 var buffer bytes.Buffer 
b，err：= json.Marshal（item）
 buffer.Write（[] byte（`{“`））
 buffer.Write（  [] byte（name））
缓冲区。Write（[] byte（`“：`）））
缓冲区。Write（b）
缓冲区。Write（[] byte（`}`））
返回缓冲区 .bytes（），err 
} 
  code>  pre> 
 
 我需要执行很多定义的结构，因此我希望有一个更好的结构 该解决方案不会给我留下100多行代码，而只是在JSON对象周围添加包装器。 理想情况下，我希望某些东西可以达到为XML编码器定义的XML元素名称的峰值，然后用它来包装JSON。 可以嵌套。 如果有帮助，我总是知道Query结构是根结构。 p> 
  div>

答

Perhaps I am missing something, but is this what you are looking for?

I started off with the same idea as @Manawasp (using a map[string]interface{}) but decided to try to get the name from the struct tag like you asked about... here's what I came up with (*note: there may be unhandled error cases, and this may overcomplicate something that can be handled pretty easily with the other solution)

http://play.golang.org/p/qO6tDZjtXA

package main

import (
    "fmt"
    "reflect"
    "strings"
)
import (
    "encoding/json"
    "encoding/xml"
    "errors"
)

type Query struct {
    XMLName xml.Name `xml:"http://marklogic.com/appservices/search query" json:"-"`
    Field1  string
    Field2  int64
}

type TermQuery struct {
    XMLName xml.Name `xml:"http://marklogic.com/appservices/search term-query" json:"-"`
    Field3  string
    Field4  int64
}

func getXmlName(d interface{}, label string) (string, bool) {
    switch reflect.TypeOf(d).Kind() {
    case reflect.Struct:
        v, _ := reflect.TypeOf(d).FieldByName(label)
        parts := strings.Split(v.Tag.Get("xml"), " ")
        return parts[1], true
    }
    return "", false
}

func wrapJson(item interface{}) ([]byte, error) {
    if n, ok := getXmlName(item, "XMLName"); ok {
        b, err := json.Marshal(map[string]interface{}{n: item})
        if err != nil {
            return nil, err
        }
        return b, nil
    }
    return nil, errors.New("You failed")
}

func main() {
    // create a Query and encode it as {"query": {struct}}
    q := Query{Field1: "hello", Field2: 42}
    wrappedQ, err := wrapJson(q)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(wrappedQ))

    // create a TermQuery and encode it as {"term-query": {struct}}
    tq := TermQuery{Field3: "world", Field4: 99}
    wrappedTQ, err := wrapJson(tq)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(wrappedTQ))

}

OUTPUT

{"query":{"Field1":"hello","Field2":42}}
{"term-query":{"Field3":"world","Field4":99}}

EDIT
Ok, here is an update now that I can see what your issue is. It might be ugly, and it might not be bullet-proof (error handling, etc)... but for my test it seems to do what you want.

http://play.golang.org/p/8MloLP3X4H

package main

import (
    "fmt"
    "reflect"
    "strings"
)
import (
    //"encoding/json"
    "encoding/json"
    "encoding/xml"
    "errors"
)

type Query struct {
    XMLName xml.Name `xml:"http://marklogic.com/appservices/search query" json:"-"`
    Field1  string
    Field2  int64
    Queries []interface{} `xml:",any" json:"queries"`
}

type TermQuery struct {
    XMLName xml.Name `xml:"http://marklogic.com/appservices/search term-query" json:"-"`
    Field3  string
    Field4  int64
}

func getXmlName(d interface{}, label string) (string, bool) {
    switch reflect.TypeOf(d).Kind() {
    case reflect.Struct:
        v, _ := reflect.TypeOf(d).FieldByName(label)
        parts := strings.Split(v.Tag.Get("xml"), " ")
        return parts[1], true
    default:
        fmt.Println(reflect.TypeOf(d).Kind())
    }
    return "", false
}

func wrapJson(item interface{}) (map[string]interface{}, error) {
    if n, ok := getXmlName(item, "XMLName"); ok {

        if k := reflect.ValueOf(item).FieldByName("Queries"); k.IsValid() {
            for i := 0; i < k.Len(); i++ {
                b, err1 := wrapJson(k.Index(i).Interface())
                if err1 != nil {

                    continue
                }
                k.Index(i).Set(reflect.ValueOf(b))

            }

        }
        return map[string]interface{}{n: item}, nil
    }
    return nil, errors.New("You failed")
}

func asJson(i interface{}) []byte {
    b, err := json.Marshal(i)
    if err != nil {
        return []byte(`{"error": "too bad"}`)
    }
    return b
}

func main() {

    // create a TermQuery and encode it as {"term-query": {struct}}
    tq := TermQuery{Field3: "world", Field4: 99}
    wrappedTQ, err := wrapJson(tq)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(asJson(wrappedTQ)))

    // create a Query and encode it as {"query": {struct}}
    q := Query{
        Field1: "hello", 
        Field2: 42, 
        Queries: []interface{}{
            TermQuery{Field3: "world", Field4: 99},
            TermQuery{Field3: "yay, it works!", Field4: 666},
            Query{
                Field1: "Hi",
                Field2: 21,
                Queries: []interface{}{
                    TermQuery{
                        Field3: "omg",
                        Field4: 1,
                    },
                },
            },
        },
    }
    wrappedQ, err := wrapJson(q)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(asJson(wrappedQ)))

}

PRETTY-PRINTED OUTOUT

{
    "query": {
        "Field1": "hello",
        "Field2": 42,
        "queries": [
            {
                "term-query": {
                    "Field3": "world",
                    "Field4": 99
                }
            },
            {
                "term-query": {
                    "Field3": "yay, it works!",
                    "Field4": 666
                }
            },
            {
                "query": {
                    "Field1": "Hi",
                    "Field2": 21,
                    "queries": [
                        {
                            "term-query": {
                                "Field3": "omg",
                                "Field4": 1
                            }
                        }
                    ]
                }
            }
        ]
    }
}

答

When I started to use Go & Json I had the same problem. I resolved it by that

func wrapJSON(name string, item interface{}) ([]byte, error) {
    wrapped := map[string]interface{}{
       name: item,
    }
    converted, err := json.Marshal(wrapped)
    return converted
}

Ideally, rename your method wrapJSON to wrap that return an interface and after convert this interface to JSON or XML

有没有更简单的方法可以使用Golang JSON编码在JSON对象上添加图层？

相关推荐