Golang 的 JSON 包

singee發表於2020-01-13
GolangJSON

本文對常見的 json 包做一些介紹，方便快速入門。每一小節均有示例說明。大家在實際開發中可以選擇適合自己的 json 包。

encoding/json

encoding/json 是官方提供的標準 json, 實現 RFC 7159 中定義的 JSON 編碼和解碼。使用的時候需要預定義 struct，原理是通過 reflection 和 interface 來完成工作，效能低。

常用的介面：

  • func Marshal(v interface{}) ([]byte, error) 生成 JSON
  • func Unmarshal(data []byte, v interface{}) error 解析 JSON 到 struct

示例 1 生成 JSON：

type ColorGroup struct {
    ID     int
    Name   string
    Colors []string
}

group := ColorGroup{
    ID:     1,
    Name:   "Reds",
    Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}

b, err := json.Marshal(group)
if err != nil {
    fmt.Println("error:", err)
}

os.Stdout.Write(b)

Output:

{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}

示例 2 解析 JSON：

var jsonBlob = []byte(`[
    {"Name": "Platypus", "Order": "Monotremata"},
    {"Name": "Quoll",    "Order": "Dasyuromorphia"}
]`)

type Animal struct {
    Name  string
    Order string
}
var animals []Animal
err := json.Unmarshal(jsonBlob, &animals)
if err != nil {
    fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)

Output:

[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

easyjson, ffjson

標準庫效能的瓶頸在反射。easyjson, ffjson 並沒有使用反射方式實現，而是在 Go 中為結構體生成靜態 MarshalJSON 和 UnmarshalJSON 函式，類似於預編譯。呼叫編碼解碼時直接使用生成的函式，從而減少了對反射的依賴，所以通常快 2 到 3 倍。但相比標準 JSON 包，使用起來略為繁瑣。

使用步驟：

1、定義結構體，每個結構體註釋裡標註 //easyjson:json 或者 //ffjson: skip；
2、使用 easyjson 或者 ffjson 命令將指定目錄的 go 結構體檔案生成帶有 Marshal、Unmarshal 方法的新檔案；
3、程式碼裡如果需要進行生成 JSON 或者解析 JSON，呼叫生成檔案的 Marshal、Unmarshal 方法即可。

下面是使用示例。

easyjson

GitHub：https://github.com/mailru/easyjson

1、先安裝：go get -u github.com/mailru/easyjson/

2、定義結構體：

記得在需要使用 easyjson 的結構體上加上 //easyjson:json。 如下：

//easyjson:json
type School struct {
    Name string     `json:"name"`
    Addr string     `json:"addr"`
}

//easyjson:json
type Student struct {
    Id       int       `json:"id"`
    Name     string    `json:"s_name"`
    School   School    `json:"s_chool"`
    Birthday time.Time `json:"birthday"`
}

3、在結構體包下執行 easyjson -all student.go

此時在該目錄下出現一個新的檔案：easyjson_student.go，該檔案給結構體增加了 MarshalJSON、UnmarshalJSON 等方法。

4、使用

package main

import (
    "studygo/easyjson"
    "time"
    "fmt"
)

func main(){
    s:=easyjson.Student{
        Id: 11,
        Name:"qq",
        School:easyjson.School{
            Name:"CUMT",
            Addr:"xz",
        },
        Birthday:time.Now(),
    }
    bt,err:=s.MarshalJSON()
    fmt.Println(string(bt),err)

    json:=`{"id":11,"s_name":"qq","s_chool":{"name":"CUMT","addr":"xz"},"birthday":"2017-08-04T20:58:07.9894603+08:00"}`
    ss:=easyjson.Student{}
    ss.UnmarshalJSON([]byte(json))
    fmt.Println(ss)
}

執行結果：

{"id":11,"s_name":"qq","s_chool":{"name":"CUMT","addr":"xz"},"birthday":"2017-08-04T20:58:07.9894603+08:00"} <nil>
{121  {CwwwwwwwUMT xzwwwww} 2017-08-04 20:52:03.4066002 +0800 CST}

ffjson

GitHub：https://github.com/pquerna/ffjson

本小節就不給示例了，大家直接看 github 上說明。用法與 easyjson 類似。

需要注意的是，ffjson 也提供了 ffjson.Marshal 和 ffjson.Unmarshal 方法，如果沒有使用 ffjson 給對應結構體生成靜態的方法，則會呼叫標準庫 encoding/json 進行編碼解碼：

func Marshal(v interface{}) ([]byte, error) {
  //呼叫結構體的靜態方法
    f, ok := v.(marshalerFaster)
    if ok {
        buf := fflib.Buffer{}
        err := f.MarshalJSONBuf(&buf)
        b := buf.Bytes()
        if err != nil {
            if len(b) > 0 {
                Pool(b)
            }
            return nil, err
        }
        return b, nil
    }

  //呼叫encoding/json
    j, ok := v.(json.Marshaler)
    if ok {
        return j.MarshalJSON()
    }
    return json.Marshal(v)
}

json-iterator/go

這是一個很神奇的庫，滴滴開發的，不像 easyjson 和 ffjson 都使用了預編譯，而且 100% 相容 encoding/json 的高效能 json 庫。根據作者的壓測介紹，該庫比 easyjson 效能還要好那麼一點點（有點懷疑～）。

json-iterator 使用 modern-go/reflect2 來優化反射效能。然後就是通過大幅度減少反射操作，來提高速度。

Github: https://github.com/json-iterator/go

首先來看下用法：

標準庫寫法：

import "encoding/json"
json.Marshal(&data)

json-iterator 寫法：

import "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Marshal(&data)

此外，該庫還提供了個功能，對於從 PHP 轉過來的朋友很有幫助。

PHP 是弱型別，所以介面裡經常把數字 10 寫成字串”10″返回，導致一個表達年齡的 JSON 變成了這樣：

{
    "age": "10"
}

golang 標準庫的 json 並不能相容這種情況下的解析，因此如果我們的 struct 企圖使用 int 來反射這個欄位，將會導致 decode 失敗。此時 json-iterator/go 就派上用場了：

package main

import (
    "fmt"
    jsoniter "github.com/json-iterator/go"
    "github.com/json-iterator/go/extra"
)

var json = jsoniter.ConfigCompatibleWithStandardLibrary

func init() {
    // RegisterFuzzyDecoders decode input from PHP with tolerance.
    //  It will handle string/number auto conversation, and treat empty [] as empty struct.
    extra.RegisterFuzzyDecoders()
}

type StdStruct struct {
    Age int `json:"age"`
}

func main() {
    s := `{"age": "10"}`

    d := &StdStruct{}

    if err := json.Unmarshal([]byte(s), d); err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(d.Age)
    }
}

輸出：

10

我們只需要在 main 檔案裡的 init 方法中開啟 1 次 PHP 相容模式即可，後續引入的模組不需要重複開啟。

go-simplejson, gabs, jason

這幾個包都是在 encoding/json 的基礎上進行開發的，為了是更方便的操作 JSON：它不需要建立 struct，而是動態按欄位取內容。它們大部分只是一個解析庫，並沒有序列化的介面。有時候我們僅僅想取 JSON 裡的某個欄位，用這個非常有用。

下面是 go-simplejson 示例。

go-simplejson

Github: https://github.com/bitly/go-simplejson

package main

import (
    "fmt"
    "github.com/bitly/go-simplejson"
)

func main() {

    data := []byte(`{
      "hits":{
          "total":2,
          "max_score":4.631368,
          "hits":[
              {
                  "_source":{
                      "account_number":298,
                      "balance":34334,
                      "firstname":"Bullock",
                      "lastname":"Marsh"
                  }
              }
          ]
      }
  }`)

    js, _ := simplejson.NewJson(data)

    //get total
    total, _ := js.Get("hits").Get("total").Int64()
    fmt.Println(total)

    account_number, _ := js.Get("hits").Get("hits").GetIndex(0).Get("_source").Get("account_number").Int64()
    fmt.Println(account_number)

    //get _source list
    hitsjson, _ := js.Get("hits").Get("hits").MarshalJSON()
    fmt.Printf("%s", hitsjson)
}

輸出：

2
298
[{"_id":"298","_index":"bank","_score":4.631368,"_source":{"account_number":298,"balance":34334,"firstname":"Bullock","lastname":"Marsh"},"_type":"account"}]

go-simplejson 沒有提供類似 Each 方法，無法對陣列型別的進行遍歷。但是我們可以將陣列取到後呼叫 MarshalJSON 生成 JSON，使用標準的 encoding/json 進行解析。

gabs

Github: https://github.com/Jeffail/gabs


import (
    "fmt"
    "github.com/Jeffail/gabs/v2"
)

func main() {

  data := []byte(`{}`) //注：為節省篇幅，data結構參考go-simplejson

    js, _ := gabs.ParseJSON(data)

    //get total
    var total float64
    //使用斷言，否則型別錯誤會報錯
    if val, ok := js.Path("hits.total").Data().(float64); ok {
        total = val
    }
    total2 := js.Search("hits", "total").Data().(float64)
    total3 := js.S("hits", "total").Data().(float64) // S is shorthand for Search

    gObj, _ := js.JSONPointer("/hits/total")
    total4 := gObj.Data().(float64)
    fmt.Println(total, total2, total3, total4)

    exist := js.Exists("hits", "total")
    fmt.Println(exist)

    account_number := js.Path("hits.hits.0._source.account_number").Data().(float64)
    fmt.Println(account_number)

    //Iterating arrays
    for _, v := range js.S("hits", "hits").Children() {
        lastname := v.S("_source", "lastname").Data().(string)
        fmt.Printf("%v\n", lastname)
    }
}

輸出：

2 2 2 2
true
298
Marsh

除此之外，gabs 還支援重新動態生成 JSON、合併 JSON 等操作。但是解析需要使用斷言這一點不是很方便。

jason

Github: https://github.com/antonholmquist/jason

示例：

package main

import (
    "fmt"
    "github.com/antonholmquist/jason"
)

func main() {

    data := []byte(`{}`) //注：為節省篇幅，data結構參考go-simplejson

    js, _ := jason.NewObjectFromBytes(data)

    //get total
    total, _ := js.GetInt64("hits", "total")
    fmt.Println(total)

    //get _source list
    hitsjson, _ := js.GetObjectArray("hits", "hits")
    for _, v := range hitsjson {
        lastname, _ := v.GetString("_source", "lastname")
        fmt.Printf("%v\n", lastname)
    }
}

輸出：

2
Marsh

提供了遍歷陣列的方法，但是沒有提供按索引取某個陣列的方法。

jsonparser

jsonparser 功能與 go-simplejson 類似，只是一個解析庫，並沒有序列化的介面。但是由於底層不是基於 encoding/json 開發的，官方宣稱它比 encoding/json 快 10 倍。

GitHub： https://github.com/buger/jsonparser

下面是個解析 ES 的示例：

package main

import (
    "encoding/json"
    "fmt"
    "github.com/buger/jsonparser"
)

type UserInfo struct {
    AccountNumber int64  `json:"account_number"`
    Balance       int64  `json:"balance"`
    Firstname     string `json:"firstname"`
    Lastname      string `json:"lastname"`
}

func main() {

    data := []byte(`{}`) //注：為節省篇幅，data結構參考go-simplejson

    //get total
    total, _ := jsonparser.GetInt(data, "hits", "total")
    fmt.Println(total)

    //get _source list
    var list []UserInfo
    hitsjson, _, _, _ := jsonparser.Get(data, "hits", "hits")

    type hitsMap struct {
        Source UserInfo `json:"_source,omitempty"`
    }

    var hitsMaps []hitsMap
    json.Unmarshal(hitsjson, &hitsMaps)

    for _, info := range hitsMaps {
        list = append(list, info.Source)
    }
    fmt.Printf("%+v\n", list)

    //get each _source
    jsonparser.ArrayEach(data, func(value []byte, dataType jsonparser.ValueType, offset int, err error) {
        _source, _, _, _ := jsonparser.Get(value, "_source")
        fmt.Println(string(_source))
    }, "hits", "hits")
}

輸出：

2
[{AccountNumber:298 Balance:34334 Firstname:Bullock Lastname:Marsh}]
{
  "account_number": 298,
  "balance": 34334,
  "firstname": "Bullock",
  "lastname": "Marsh"
}

大家可以看一下 elastic/go-elasticsearch 給出的示例裡是怎麼解析 JSON 的：

// Print the response status, number of results, and request duration.
  log.Printf(
    "[%s] %d hits; took: %dms",
    res.Status(),
    int(r["hits"].(map[string]interface{})["total"].(map[string]interface{})["value"].(float64)),
    int(r["took"].(float64)),
  )
  // Print the ID and document source for each hit.
  for _, hit := range r["hits"].(map[string]interface{})["hits"].([]interface{}) {
    log.Printf(" * ID=%s, %s", hit.(map[string]interface{})["_id"], hit.(map[string]interface{})["_source"])
  }

對，就是使用的斷言，這個會讓人很崩潰，萬一值不存在或者型別不對，還會直接扔個 ERROR...

總結

大部分情況下大家直接使用 encoding/json 就行了。如果追求極致的效能，考慮 easyjson。遇到解析 ES 搜尋返回的複雜的 JSON 或者僅需要解析個別欄位， go-simplejson 或者 jsonparser 就很方便了。

參考

1、json - GoDoc
https://godoc.org/encoding/json#example-Un...
2、Golang 的 json 包一覽 - 知乎
https://zhuanlan.zhihu.com/p/24451749
3、bitly/go-simplejson: a Go package to interact with arbitrary JSON
https://github.com/bitly/go-simplejson
4、buger/jsonparser: Alternative JSON parser for Go that does not require schema (so far fastest)
https://github.com/buger/jsonparser
5、Golang 高效能 json 包：easyjson - 夢朝思夕的個人空間 - OSCHINA
https://my.oschina.net/qiangmzsx/blog/1503...
6、pquerna/ffjson: faster JSON serialization for Go
https://github.com/pquerna/ffjson
7、Jeffail/gabs: For parsing, creating and editing unknown or dynamic JSON in Go
https://github.com/Jeffail/gabs
8、golang – 利用 json-iterator 庫相容解析 PHP JSON | 魚兒的部落格
https://yuerblog.cc/2019/11/08/golang-%e5%88%a9%e7%94%a8json-iterator%e5%ba%93%e5%85%bc%e5%ae%b9%e8%a7%a3%e6%9e%90php-json/
9、json-iterator 使用要注意的大坑 – 萌叔
http://vearne.cc/archives/433
10、golang json 效能分析 - - SegmentFault 思否
https://segmentfault.com/a/119000001302278...

出處

本文來源於 https://www.cnblogs.com/52fhy/p/11830755.h... ，僅對格式有所修改

本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章