再測Golang的JSON庫

qiangmzsx發表於2018-02-11

寫專案一直需要進行序列化，聽到了，也看到了很多同學老師對各個golang的json庫進行測評。那本人為什麼還要繼續進行這一次測評呢？因為實踐過的知識最有說服力，也是屬於自己的，我也希望看到本博文的同學老師可以修改和執行測評的程式碼執行一遍，我相信會有不一定的體會。本次測評我選擇了類庫有：

類庫

序號	類庫	地址
1	encoding/json	Golan
2	easyjson	github.com/mailru/easyjson
3	ffjson	github.com/mailru/easyjson
4	iterator/json	github.com/json-iterator/go

主要是針對上述的型別進行，本人採用了對不同的類庫使用不同的結構體（僅僅是結構體名稱不同，欄位順序和型別一樣）。

環境

環境為MacBook Pro（Core i5處理器/8GB記憶體）go1.8.3 darwin/amd64

程式碼

bench程式碼如下：

package jsonbench

import (
    "encoding/gob"

    "encoding/json"
    "github.com/json-iterator/go"
    "github.com/mailru/easyjson"
    "github.com/pquerna/ffjson/ffjson"
    "testing"
)

var (
    iterator = jsoniter.ConfigCompatibleWithStandardLibrary
    // easyjson
    as = AgentService{
        ServiceName:    "kaleidoscope_api",
        Version:        "1517558949087295000_1298498081",
        ServiceId:      "kaleidoscope.com_v1.2",
        Address:        "127.0.0.1",
        Port:           80,
        Metadata:       map[string]string{},
        ConnectTimeOut: 1000,
        ConnectType:    "LONG",
        ReadTimeOut:    1000,
        WriteTimeOut:   1000,
        Protocol:       "HTTP",
        Balance:        "Random",
        Idcs:           "hu,hd,hn",
        Converter:      "json",
        Retry:          3,
    }
    service            = as.ToService()
    asBytes, _         = json.Marshal(as)
    serviceBytes, _    = json.Marshal(service)
    asStr              = string(asBytes)
    serviceStr         = string(serviceBytes)
    asGonBytes, _      = GobEncode(as)
    serviceGonBytes, _ = GobEncode(service)
    // std
    asstd = AgentServiceSTD{
        ServiceName:    "kaleidoscope_api",
        Version:        "1517558949087295000_1298498081",
        ServiceId:      "kaleidoscope.com_v1.2",
        Address:        "kaleidoscope.dev.igetget.com",
        Port:           80,
        Metadata:       map[string]string{},
        ConnectTimeOut: 1000,
        ConnectType:    "LONG",
        ReadTimeOut:    1000,
        WriteTimeOut:   1000,
        Protocol:       "HTTP",
        Balance:        "Random",
        Idcs:           "hu,hd,hn",
        Converter:      "json",
        Retry:          3,
    }
    servicestd            = asstd.ToServiceSTD()
    asBytesstd, _         = json.Marshal(asstd)
    serviceBytesstd, _    = json.Marshal(servicestd)
    asStrstd              = string(asBytesstd)
    serviceStrstd         = string(serviceBytesstd)
    asGonBytesstd, _      = GobEncode(asstd)
    serviceGonBytesstd, _ = GobEncode(servicestd)
)

// go test -bench=".*"
func init() {
    gob.Register(AgentService{})
}

func Benchmark_STD_Marshal1(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := json.Marshal(asstd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_STD_Marshal2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := json.Marshal(servicestd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_STD_Marshal1(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := json.Marshal(as)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_STD_Marshal2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := json.Marshal(service)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_Marshal1(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := easyjson.Marshal(as)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_Marshal2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := easyjson.Marshal(service)
        if err != nil {
            b.Error(err)
        }
    }
}

//
func Benchmark_ITERATOR_Marshal1(b *testing.B) {

    for i := 0; i < b.N*10; i++ {
        _, err := iterator.Marshal(asstd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_ITERATOR_Marshal2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := iterator.Marshal(servicestd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_FFJSON_Marshal1(b *testing.B) {

    for i := 0; i < b.N*10; i++ {
        _, err := ffjson.Marshal(asstd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_FFJSON_Marshal2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        _, err := ffjson.Marshal(servicestd)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_GOB_Encode1(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        GobEncode(as)
    }
}

func Benchmark_GOB_Encode2(b *testing.B) {
    for i := 0; i < b.N*10; i++ {
        GobEncode(service)
    }
}

func Benchmark_STD_Unmarshal1(b *testing.B) {
    tmp := AgentServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := json.Unmarshal(asBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_STD_Unmarshal2(b *testing.B) {
    tmp := ServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := json.Unmarshal(serviceBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_STD_Unmarshal1(b *testing.B) {
    tmp := AgentService{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := json.Unmarshal(asBytes, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_STD_Unmarshal2(b *testing.B) {
    tmp := Service{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := json.Unmarshal(serviceBytes, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_Unmarshal1(b *testing.B) {
    tmp := AgentService{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := easyjson.Unmarshal(asBytes, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_EASYJSON_Unmarshal2(b *testing.B) {
    tmp := Service{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := easyjson.Unmarshal(serviceBytes, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_ITERATOR_UnMarshal1(b *testing.B) {

    tmp := ServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := iterator.Unmarshal(serviceBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_ITERATOR_UnMarshal2(b *testing.B) {
    tmp := ServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := iterator.Unmarshal(serviceBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_FFJSON_UnMarshal1(b *testing.B) {

    tmp := ServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := ffjson.Unmarshal(serviceBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_FFJSON_UnMarshal2(b *testing.B) {
    tmp := ServiceSTD{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        err := ffjson.Unmarshal(serviceBytesstd, &tmp)
        if err != nil {
            b.Error(err)
        }
    }
}

func Benchmark_GOB_Decode1(b *testing.B) {
    tmp := AgentService{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        GobDecode(asGonBytes, &tmp)
    }
}

func Benchmark_GOB_Decode2(b *testing.B) {
    tmp := Service{}
    for i := 0; i < b.N*10; i++ {
        as.Port = i
        GobDecode(serviceGonBytes, &tmp)
    }
}

執行命令：

go test -bench=".*"

測評結果;

$ go test -bench=".*"
Benchmark_STD_Marshal1-4                   50000             31224 ns/op
Benchmark_STD_Marshal2-4                   30000             49598 ns/op
Benchmark_EASYJSON_STD_Marshal1-4          30000             45778 ns/op
Benchmark_EASYJSON_STD_Marshal2-4          30000             50440 ns/op
Benchmark_EASYJSON_Marshal1-4             100000             14387 ns/op
Benchmark_EASYJSON_Marshal2-4             100000             16009 ns/op
Benchmark_ITERATOR_Marshal1-4             100000             14899 ns/op
Benchmark_ITERATOR_Marshal2-4             100000             21629 ns/op
Benchmark_FFJSON_Marshal1-4                50000             31633 ns/op
Benchmark_FFJSON_Marshal2-4                30000             51668 ns/op
Benchmark_GOB_Encode1-4                    20000             97099 ns/op
Benchmark_GOB_Encode2-4                    10000            153158 ns/op
Benchmark_STD_Unmarshal1-4                 20000             89211 ns/op
Benchmark_STD_Unmarshal2-4                 20000             76442 ns/op
Benchmark_EASYJSON_STD_Unmarshal1-4        30000             57695 ns/op
Benchmark_EASYJSON_STD_Unmarshal2-4        20000             66269 ns/op
Benchmark_EASYJSON_Unmarshal1-4           100000             19028 ns/op
Benchmark_EASYJSON_Unmarshal2-4           100000             22035 ns/op
Benchmark_ITERATOR_UnMarshal1-4            50000             35942 ns/op
Benchmark_ITERATOR_UnMarshal2-4            50000             36462 ns/op
Benchmark_FFJSON_UnMarshal1-4              20000             80290 ns/op
Benchmark_FFJSON_UnMarshal2-4              20000             78431 ns/op
Benchmark_GOB_Decode1-4                     3000            377698 ns/op
Benchmark_GOB_Decode2-4                     3000            463472 ns/op
PASS
ok      studygo/jsonbench       49.174s

結論

哪一個類庫最快？
答：是測評類庫中最快的。速度：easyjson => iterator => encoding/json => ffjson
是否存在坑？
答：easyjson有一個坑，從程式碼中可以看到Benchmark_EASYJSON_STD_*的方法，是因為easyjson生成的程式碼中已經包含了MarshalJSON和UnmarshalJSON方法，那麼只要對這些結構體執行json.marshalJSON和json.UnmarshalJSON都會預設呼叫easyjson生成的方法。本人執行多次，都會發現呼叫easyjson生成的MarshalJSON方法比標準庫中的慢一些達到50%左右，但是呼叫easyjson生成的UnmarshalJSON比標準庫的快一些大概20%。
如何選擇？
答：easyjson速度雖然比較快，但也是存在一些不適合的場景，比如如果需要對interface介面進行序列化時候。所以建議採用easyjson與標準庫結合。

Golang 的 JSON 包
2020-01-13
GolangJSON
Golang json 解析
2018-01-27
GolangJSON
golang json 示例
2015-08-25
GolangJSON
細說 Golang 的 JSON 解析
2019-12-09
GolangJSON
再談JSON/XML
2008-01-03
JSONXML
Golang 流式解析 Json
2019-02-16
GolangJSON
golang json 效能分析
2018-01-28
GolangJSON
Golang 中使用 JSON 的小技巧
2017-06-20
GolangJSON
golang json處理問題
2018-09-26
GolangJSON
GoLang之Concurrency再討論
2014-01-23
Golang
再論 golang 環境配置建議
2015-12-14
Golang
golang中的log庫
2018-08-13
Golang
Json序列化在golang中的應用
2021-03-25
JSONGolang
Golang 網路庫併發吞吐量測試
2019-09-24
Golang
golang讀取檔案的json資料流,並解析到struct,儲存到資料庫
2020-10-15
GolangJSONStruct資料庫
JSON簡介（java中的json庫使用）
2020-11-21
JSONJava
Golang高效能json包：easyjson
2021-09-09
GolangJSON
golang中struct、json、map互相轉化
2018-11-18
GolangStructJSON
Golang | IO庫
2020-04-04
Golang
Golang 的 Elastic 連結庫
2022-01-15
GolangAST
golang通過反射使用json字串呼叫struct的指定方法及返回json結果
2016-11-02
Golang反射JSON字串Struct
golang 解析php輸出json相容問題
2018-09-26
GolangPHPJSON
golang 版本的 curl 請求庫
2017-09-14
Golang
Golang專案的測試實踐
2019-05-22
Golang
golang結構體json的時間格式化解決方案
2017-07-15
Golang結構體JSON
golang 單元測試
2018-01-31
Golang
Golang高效實踐之interface、reflection、json實踐
2019-07-26
GolangJSON
Golang：將日誌以Json格式輸出到Kafka
2022-05-17
GolangJSONKafka
Golang操作結構體、Map轉化為JSON
2018-09-14
Golang結構體JSON
php 透過 JSON RPC 與 golang 通訊
2023-01-12
PHPJSONRPCGolang
再論“庫存控制”
2015-05-21
Golang結構體json的時間格式化解決辦法
2021-03-11
Golang結構體JSON
Golang 效能測試 (3) 跟蹤刨析 golang trace
2020-04-17
Golang
Json Schema簡介和Json Schema的.net實現庫 LateApexEarlySpeed.Json.Schema
2023-12-26
JSON
請教Golang處理Json，處理的是 List of Json這種情況，大家有何高見？
2017-08-02
GolangJSON
python比較json/dictionary的庫
2019-01-16
PythonJSON
Golang 編寫測試教程
2019-02-28
Golang
golang 表格驅動測試
2019-07-18
Golang

再測Golang的JSON庫

類庫

環境

程式碼

結論

相關文章