美文网首页
Go语言 Web开发(8)JSON处理

Go语言 Web开发(8)JSON处理

作者: 小杰的快乐时光 | 来源:发表于2018-08-23 06:00 被阅读0次

    JavaScript Object Notation(JSON)是一个数据交换标准,因其简单、可读性强广泛使用。Go语言中有一个"encoding/json"标准包,里面有完整的解析JSON字符串的功能支持

    Go类型和JSON类型的对应关系如下:

    • bool 代表 JSON booleans,
    • 浮点数, 整数, Number -> JSON number,
    • string 代表 JSON strings,
    • nil 代表 JSON null.
    • 数组、切片 -> JSON数组
    • struct、map -> JSON object

    (1)将JSON数据解析成结构体,需要用到 Unmarshal 函数,该函数的源码如下

    func Unmarshal(data []byte, v interface{}) error {
        //检查结构良好。
        //避免填写半数据结构
        //在发现JSON语法错误之前
       var d decodeState
       err := checkValid(data, &d.scan)
       if err != nil {
          return err
       }
       d.init(data)
       return d.unmarshal(v)
    }
    

    解析示例
    首先定义一个结构体与数组切片

    //与json数据对应的结构体
    type Server struct {
       ServerName string
       ServerIP   string
    }
    // 数组对应slice
    type ServerSlice struct {
       Servers []Server
    }
    

    然后将JSON数据解析成结构体

    package main
    
    import (
       "encoding/json"
       "fmt"
    )
    func main()  {
       var s ServerSlice
       str := `{"servers":[{"serverName":"TianJin","serverIP":"127.0.0.1"},
    {"serverName":"Beijing","serverIP":"127.0.0.2"}]}`
       json.Unmarshal([]byte(str), &s)
       fmt.Println(s)
    }
    
    ----output-----
    {[{TianJin 127.0.0.1} {Beijing 127.0.0.2}]}
    

    按照上述代码可以正常的将JSON解析成结构体,JSON在struct字段相中查找对应的字段有以下几个规则:
    ①首先会查找struct字段中所有的可导出的struct字段(所谓可导出就是首字母大写),然后去自己的JSON数据中找对应字段的数据
    ②JSON数据中对应的字段无关大小写,只要值相同即可

    因此上面的Server 结构体中的 ServerName 改为 serverName的话,输出结果就只有后面的 ServerIP 了

    {[{ 127.0.0.1} { 127.0.0.2}]}
    

    (2)将结构体解析为JSON数据,需要用到 Unmarshal 函数,该函数的源码如下

    func Marshal(v interface{}) ([]byte, error) {
       e := &encodeState{}
       err := e.marshal(v, encOpts{escapeHTML: true})
       if err != nil {
          return nil, err
       }
       return e.Bytes(), nil
    }
    

    将结构体解析成JSON数据

    func main()  {
       var s ServerSlice
       s.Servers = append(s.Servers,Server{ServerName:"TianJin",
    ServerIP:"127.0.0.1"})
       s.Servers = append(s.Servers,Server{ServerName:"BeiJing",
    ServerIP:"127.0.0.1"})
       if data, err := json.Marshal(s); err == nil {
          fmt.Printf("%s\n", data)
       }
    }
    ---output---
    {"Servers":[{"ServerName":"TianJin","ServerIP":"127.0.0.1"},
    {"ServerName":"BeiJing","ServerIP":"127.0.0.1"}]}
    

    如果我们要自己定义生成的JSON数据的字段名呢?我们可以通过 struct tag定义来实现

    //与json数据对应的结构体
    type Server struct {
       ServerName string `json:"serverName1"`
       ServerIP string `json:"serverIP2"`
    }
    // 数组对应slice
    type ServerSlice struct {
       Servers []Server `json:"servers3"`
    }
    

    上面的JSON就会变为下面结果

    {"servers3":[{"serverName1":"TianJin","serverIP2":"127.0.0.1"},
    {"serverName1":"BeiJing","serverIP2":"127.0.0.1"}]}
    

    针对JSON的输出,我们在定义struct tag的时候需要注意的几点是:
    1 字段的tag是 "-" ,那么这个字段不会输出到JSON
    2 tag中带有自定义名称,那么这个自定义名称会出现在JSON的字段名中,例如上面例子中serverName
    3 tag中如果带有 "omitempty" 选项,那么如果该字段值为空,就不会输出到JSON串中
    4 如果字段类型是bool, string, int, int64等,而tag中带有 ",string" 选项,那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串
    举例说明

    type Server struct {
       // ID  不会导出到 JSON 中
       ID int `json:"-"`
       // ServerName 会在JSON中被 serverName 覆盖
       ServerName string `json:"serverName"`
        //转换成JSON字符串
       ServerName2 string `json:"serverName2,string"`
       //  如果 ServerIP  为空,则不输出到 JSON 串中
       ServerIP string `json:"serverIP,omitempty"`
    }
    s := Server {
       ID: 3,
       ServerName: `Go "1.0" `,
       ServerName2: `Go "1.0" `,
       ServerIP: ``,
    }
    b, _ := json.Marshal(s)
    os.Stdout.Write(b)
    会输出以下内容:
    {"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}
    

    Marshal函数只有在转换成功的时候才会返回数据,在转换的过程中我们需要注意几点:
    ①JSON对象只支持string作为key,所以要编码一个map,那么必须是map[string]T这种类型(T是Go语言中任意的类型)
    ②Channel, complex和function是不能被编码成JSON的
    ③嵌套的数据是不能编码的,不然会让JSON编码进入死循环
    ④指针在编码的时候会输出指针指向的内容,而空指针会输出null

    上面解析方式是在我们知晓被解析的JSON数据的结构的前提下采取的方案,如果我们不知道被解析的数据的格式,又应该如何来解析呢?
    (3)将JSON解析到interface

    现在我们假设有如下的JSON数据
    b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
    在我们不知道他的结构的情况下,我们把他解析到interface{}里面
    var f interface{}
    err := json.Unmarshal(jsonData, &f)
    

    这个时候f里面存储了一个map类似,他们的key是string,值存储在空的interface{}里

    f = map[string]interface{}{
        "Name": "Wednesday",
        "Age": 6,
        "Parents": []interface{}{
                    "Gomez",
                    "Morticia",
        },
    }
    

    那么如何来访问这些数据呢?通过断言的方式:

    m := f.(map[string]interface{})
    通过断言之后,你就可以通过如下方式来访问里面的数据了
    for k, v := range m {
       switch vv := v.(type) {
       case string:
          fmt.Println(k, "is string", vv)
       case int:
          fmt.Println(k, "is int", vv)
       case []interface{}:
          fmt.Println(k, "is an array:")
          for i, u := range vv {
             fmt.Println(i, u)
          }
       default:
          fmt.Println(k, "is of a type I don't know how to handle")
       }
    }
    

    参考书籍:《Go Web编程》

    相关文章

      网友评论

          本文标题:Go语言 Web开发(8)JSON处理

          本文链接:https://www.haomeiwen.com/subject/jiouiftx.html