go 中解析JSON的三種姿勢

2022 年 9 月 13 日
筆記
Go, golang精進, json

背景

這是一篇寫給0-1年新人的文章，短平快的教會你如何解析json字元串。

示例Json

假設有如下json字元串：

{
   "userName":"admin",
   "nick_name":"管理員",
   "info":{
      "age":18
   },
   "extra":[
      {
         "address":"上海市"
      },
      {
         "address":"北京市"
      }
   ]
}

我們來看看，如何在go中解析。

例子

直接上程式碼：

package main
 
import (
    "encoding/json"
    "log"
    "github.com/tidwall/gjson"
)
 
// 嵌套一個對象
type Info struct {
    Age int `json:"age"`
}
 
var info = Info{Age: 12}
 
// 嵌套一個對象數組
type Extra struct {
    Address string `json:"address"`
}
 
// 定義需要反序列化的結構體
type UserRequest struct {
    Name     string  `json:"userName"`  // 通過tag裡面的json，來指定json字元串中該欄位的值從那裡解析，不需要和欄位名一樣
    NickName string  `json:"nick_name"` // 如果沒對應上，解析不了
    info     Info    `json:"info"`      // 小寫私有的，故反序列化失效，該欄位永遠為空
    Extra    []Extra `json:"extra"`
}
 
func main() {
    jsonStr := `
    {
        "userName":"admin",
        "nick_name":"管理員",
        "info":{
           "age":18
        },
        "extra":[
           {
              "address":"上海市"
           },
           {
              "address":"北京市"
           }
        ]
     }`
 
    // 方式一：序列化成map，經常使用
    anyMap := make(map[string]interface{}, 0)
    if err := json.Unmarshal([]byte(jsonStr), &anyMap); err != nil {
        panic(err)
    }
    log.Println("Unmarshal to map result:", anyMap)
 
    // 方式二：反序列化成對象，經常使用
    req := UserRequest{}
    if err := json.Unmarshal([]byte(jsonStr), &req); err != nil {
        panic(err)
    }
    log.Println("Unmarshal to struct:", req)
 
    // 方式三：不反序列化，只讀取單個key，經常使用。適合特別複雜的json字元串，或者有多種if else結構的場景
    userName := gjson.Get(jsonStr, "userName")
    nickName := gjson.Get(jsonStr, "nick_name")
    age := gjson.Get(jsonStr, "info.age").Int()
 
    // 取得extra數組0位置的對象
    address1 := gjson.Get(jsonStr, "extra").Array()[1]
    log.Println("get raw value by key:", userName, nickName, age, address1.Get("address"))
}

運行後輸出：

2022/09/13 11:09:13 Unmarshal to map result: map[extra:[map[address:上海市] map[address:北京市]] info:map[age:18] nick_name:管理員 userName:admin]
2022/09/13 11:09:13 Unmarshal to struct: {admin 管理員 {0} [{上海市} {北京市}]}
2022/09/13 11:09:13 get raw value by key: admin 管理員 18 北京市

解釋

1）反序列化成map

    anyMap := make(map[string]interface{}, 0)
    if err := json.Unmarshal([]byte(jsonStr), &anyMap);
    //...

我們看到，key是string，value是interface{}，所以你取值的時候，需要這樣取：

ageVal,ok := anyMap["age"]
if ok{
    age := ageVal.(int)
    log.Println(age)
}

是不是感覺非常麻煩？一是需要判斷key是否存在，二是類型轉換。

所以，反序列化時這種方式不是很常用，但是序列化的時候，非常方便，用的較多。

比如在gin框架中，就被大量使用：

type LoginReq struct {
   UserName string `json:"user_name"`
}
 
func onLogin(ctx *gin.Context) {
   req := LoginReq{}
   if err := ctx.BindJSON(&req); err != nil {
      ctx.Error(err)
   }
 
   if req.UserName == "admin" {
      ctx.JSON(http.StatusOK, gin.H{"code": 0, "msg": "success"})
   } else {
      ctx.JSON(http.StatusUnauthorized, gin.H{"code": -1, "msg": "帳號錯誤！"})
   }
}

看到 gin.H 了嗎？實際上就是：

// H is a shortcut for map[string]interface{}
type H map[string]interface{}

所以：

ctx.JSON(http.StatusOK, gin.H{"code": 0, "msg": "success」})

等價於：

ctx.JSON(http.StatusOK, map[string]interface{}{"code": 0, "msg": "success"})

這樣做的好處是，不需要預先定義結構體，直接通過語法糖實現，程式碼更簡潔。

2）反序列化成對象

這個是最常用的，通過 `json.Unmarshal` 把二進位反序列化成對象，通過 `json.Marshal()` 把對象序列化成json字元串。需要注意的是：

欄位tag中的名字要和json字元串中的對應，否則解析不到值
欄位名不能是小寫開頭，私有的欄位無法將被忽略，也會解析不到值
支援嵌套，由go標準庫通過反射自動完成

3）複雜json的解析

有時候，一個json非常複雜，或者你只需要取某個欄位，那麼就可以使用這種方式：

userName := gjson.Get(jsonStr, "userName")

別忘記，gjson 不是標準庫的包，需要使用 go get github.com/tidwall/gjson 安裝。

總結

本文介紹了解析json的3種方式：

直接解析成 map[string]interface{}
解析成對象
讀取單個key

這3種方式沒有好壞之分，只看具體的場景，靈活使用即可。唯一不變的是，都是通過 `json.Unmarshal` 把二進位反序列化成對象，通過 `json.Marshal()` 把對象序列化成json字元串。

加餐：什麼是序列化？

百科中說：序列化 (Serialization)是將對象的狀態資訊轉換為可以存儲或傳輸的形式的過程。

通俗點說就是因為網路只能發送二進位流，而我們程式碼中的數據又是保存在各種對象中。在C/S（客戶端/伺服器）架構中，客戶端傳遞數據給伺服器勢必就要進行2次轉換。

客戶端：發送之前，要把對象轉換為二進位位元組流。
伺服器：接收到二進位流之後，要轉換為對象。

這種從對象到二進位流的過程叫序列化（Serialization），反過來從二進位流轉換成對象就叫反序列化。

References：

Tags: Go golang精進 json