Golang json文件处理

  JSON（Javascript Object Notation）是一种轻量级的数据交换语言，以文字为基础，具有自我描述性且易于让人阅读。尽管JSON是Javascript的一个子集，但JSON是独立于语言的文本格式，并且采用了类似于 C语言 家族的一些习惯。JSON与XML最大的不同在于XML是一个完整的标记语言，而JSON不是。JSON由于比XML更小、更快，更易解析,以及浏览器的内建快速解析支持,使得其更适用于网络数据传输领域。目前我们看到很多的开放平台，基本上都是采用了JSON作为他们的数据交互的接口。既然JSON在Web开发中如此重要，那么 Go 语言对JSON支持的怎么样呢？Go语言的标准库已经非常好的支持了JSON，可以很容易的对JSON数据进行编、解码的工作。

以如下JSON源文件为例

{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"},{"serverName":"Guangzhou_VPN","serverIP":"127.0.0.3"}]}

解析JSON

解析到结构体

  Golang中提供软件包 "encoding/json" 可以直接用来处理JSON文件，此包中解析JSON的函数为 Unmarshal ，使用此函数可以将JSON文件解析到结构体中。

func Unmarshal(data []byte, v interface{}) error

参考如下代码

package main

import (
    "encoding/json"
    "fmt"
)

type Server struct {
    ServerName string
    ServerIP   string
}

type Serverslice struct {
    Servers []Server
}

func main() {
    var s Serverslice
    str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"},{"serverName":"Guangzhou_VPN","serverIP":"127.0.0.3"}]}`
    json.Unmarshal([]byte(str), &s)
    fmt.Println(s)
}

上述代码的输出为

{[{Shanghai_VPN 127.0.0.1} {Beijing_VPN 127.0.0.2} {Guangzhou_VPN 127.0.0.3}]}

  上例中，首先定义了与json数据对应的结构体，数组对应slice，字段名对应JSON里面的KEY，在解析的时候，如何将json数据与struct字段相匹配呢？例如JSON的key是Foo，那么怎么找对应的字段呢？

• 首先查找tag含有Foo的可导出的struct字段(首字母大写)
• 其次查找字段名是Foo的导出字段
• 最后查找类似FOO或者FoO这样的除了首字母之外其他大小写不敏感的导出字段
    其中需要注意一点：能够被赋值的字段必须是可导出字段(即首字母大写）。同时JSON解析的时候只会解析能找得到的字段，找不到的字段会被忽略，这样的一个好处是：当你接收到一个很大的JSON数据结构而你却只想获取其中的部分数据的时候，你只需将你想要的数据对应的字段名大写，即可轻松解决这个问题。

解析到interface

  上述解析方式是在知晓被解析的JSON数据的结构的前提下采取的方案，如果不知道被解析的数据的格式，又应该如何来解析呢？

  众所周知，在Golang中， interface{} 可以用来存储任意数据类型的对象，此数据结构正好用于存储解析的未知结构的json数据的结果。JSON包中采用 map[string]interface{} 和 []interface{} 结构来存储任意的JSON对象和数组。Go类型和JSON类型的对应关系如下：

• bool 代表 JSON booleans,
• float64 代表 JSON numbers,
• string 代表 JSON strings,
• nil 代表 JSON null.
  假设有如下的JSON数据

b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)

在未知JSON结构情况下，把他解析到interface{}里面

var f interface{}
err := json.Unmarshal(b, &f)

上述代码的执行结果是 f 里面存储了一个 map 类型， key 是 string ，值存储在 interface{} 中。

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

可以通过断言来访问 interface{} 中的数据

m := f.(map[string]interface{})

在 encoding/json 包中，使用如下方式解析

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 float64:
        fmt.Println(k,"is float64",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")
    }
}

  其实很多时候使用类型断言异常繁琐，操作起来极为不便，目前bitly公司开源了一个叫做 simplejson 的包,在处理未知结构体的JSON时相当方便，详细例子如下所示：

js, err := NewJson([]byte(`{
    "test": {
        "array": [1, "2", 3],
        "int": 10,
        "float": 5.150,
        "bignum": 9223372036854775807,
        "string": "simplejson",
        "bool": true
    }
}`))

arr, _ := js.Get("test").Get("array").Array()
i, _ := js.Get("test").Get("int").Int()
ms := js.Get("test").Get("string").MustString()

使用此库操作JSON要比官方的 encoding/json 包要方便许多，详细的请参考如下地址： https://github.com/bitly/go-simplejson

生成JSON

  与解析JSON报文相反， encoding/json 包提供函数 Marshal 来包装、生成JSON字符串，此函数定义如下：

func Marshal(v interface{}) ([]byte, error)

参考如下代码

package main

import (
    "encoding/json"
    "fmt"
)

type Server struct {
    ServerName string
    ServerIP   string
}

type Serverslice struct {
    Servers []Server
}

func main() {
    var s Serverslice
    s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})
    s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})
    s.Servers = append(s.Servers, Server{ServerName: "Guangzhou_VPN", ServerIP: "127.0.0.3"})
    
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json err:", err)
    }
    fmt.Println(string(b))
}

上述代码的输出为

{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}, {"ServerName":"Guangzhou_VPN", "ServerIP":"127.0.0.3"}]}

  需要注意，上面的输出字段名的首字母都是大写的，如果想用小写的首字母怎么办呢？把结构体的字段名改成首字母小写的？JSON输出的时候必须注意，只有导出的字段才会被输出，如果修改字段名，那么就会发现什么都不会输出，所以必须通过struct tag定义来实现：

type Server struct {
    ServerName string `json:"serverName"`
    ServerIP   string `json:"serverIP"`
}

type Serverslice struct {
    Servers []Server `json:"servers"`
}

通过修改上面的结构体定义，输出的JSON串就和最开始定义的JSON串保持一致了。

针对JSON的输出，在定义struct tag的时候需要注意如下内容:

• 字段的tag是"-"，那么这个字段不会输出到JSON
• tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中，例如上面例子中serverName
• tag中如果带有"omitempty"选项，那么如果该字段值为空，就不会输出到JSON串中
• 如果字段类型是bool, string, int, int64等，而tag中带有",string"选项，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串
  比如

type Server struct {
    // ID 不会导出到JSON中
    ID int `json:"-"`

    // ServerName2 的值会进行二次JSON编码
    ServerName  string `json:"serverName"`
    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