go 中解析JSON的三种姿势

Go和分布式IM

已于 2022-09-13 16:16:47 修改

阅读量7.5k

点赞数 9

分类专栏： Golang学习和进阶文章标签： json golang 开发语言

于 2022-09-13 16:00:05 首次发布

本文链接：https://blog.csdn.net/xmcy001122/article/details/126835290

版权

Golang学习和进阶专栏收录该内容

34 篇文章 7 订阅

订阅专栏

背景

这是一篇写给0-1年新人的文章，短平快的教会你如何解析json字符串。

一个简单的json字符串

假设有如下json字符串：

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

我们来看看，如何在go中解析。

Json解析的3种方式

方式一：反序列化成map

示例

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

输出如下：

2022/09/13 11:09:13 Unmarshal to map result: map[extra:[map[address:上海市] map[address:北京市]] info:map[age:18] nick_name:管理员 userName:admin]

我们看到，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"})

这样做的好处是，不需要预先定义结构体，直接写在返回结果中，代码更简洁。另外因为map的value是interface，可以进行嵌套返回：

ctx.JSON(http.StatusOK, gin.H{
            "status":  gin.H{
                "code": http.StatusOK,
                "status": "登录成功",
            },
            "message":"success"
        })

方式二：反序列化成对象

我们需要先把结构体定义好：

// 嵌套一个对象
type Info struct {
    Age int `json:"age"`
}

// 嵌套一个对象数组
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"`
}

这个是最常用的，通过 json.Unmarshal 把二进制反序列化成对象，通过 json.Marshal() 把对象序列化成json字符串。

    req := UserRequest{}
    if err := json.Unmarshal([]byte(jsonStr), &req); err != nil {
        panic(err)
    }
    log.Println("Unmarshal to struct:", req)

运行后输出：

2022/09/13 11:09:13 Unmarshal to struct: {admin 管理员 {0} [{上海市} {北京市}]}

需要注意的是：

字段tag中的名字要和json字符串中的对应，否则解析不到值
字段名不能是小写开头，私有的字段无法将被忽略，也会解析不到值
支持嵌套，由go标准库通过反射自动完成

方式三：复杂json的解析

有时候，一个json非常复杂，或者你只需要取某个字段，那么就可以使用这种方式：

// 方式三：不反序列化，只读取单个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 get raw value by key: admin 管理员 18 北京市

别忘记，gjson 不是标准库的包，需要使用 go get github.com/tidwall/gjson 安装。

完整代码

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 北京市