解析到结构体
// json.go
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"}]}`
json.Unmarshal([]byte(str), &s)
fmt.Println(s)
fmt.Println(s.Servers[0].ServerIP)
}outputs:
{[{Shanghai_VPN 127.0.0.1} {Beijing_VPN 127.0.0.2}]}
127.0.0.1
首先定义了与json数据对应的结构体，数组对应slice,字段名对应JSON里面的KEY,在解析的时候，如何将JSON数据与struct字段相匹配呢？如JSON的key是Foo，那么怎么找对应的字段呢？
首先查找tag含有Foo的可导出的struct字段(首字母大写)
其次查找字段名是Foo的导出字段
最后查找类似FOO或者FoO这样的除了首字母之外其他大小写不敏感的导出字段
能够被赋值的字段必须是可导出字段（即首字母大写）。同时JSON解析的时候只会解析能找到的字段，如果找不到的字段会被忽略，这样的一个好处是：当你接收到一个很大的JSON数据结构而你却只想获取其中的部分数据的时候，你只需将你想要的数据对应的字段名大写，即可轻松解决问题。
解析到interface
我们知道interface{}可以用来存储任意数据类型的对象，这种数据结构正好用于存储解析的未知结构的json数据的结果。JSON包中采用map[string]interface{}和[]interface{}结构来存储任意的JSON对象和数组。Go类型和JSON类型的对应关系如下：
bool代表JSON booleans
float64代表JSON numbers
string代表JSON strings
nil 代表JSON null
通过断言方式访问数据，如下例：
// tointer.go
package main
import (
"encoding/json"
"fmt"
)
func main() {
b := []byte(`{"Name":"Wednesday", "Age":6, "Parents": [ "Gomez", "Moticia" ]}`)
var f interface{}
err := json.Unmarshal(b, &f)
if err != nil {
fmt.Println(err)
}
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")
}
}
}outputs:
Name is string Wednesday
Age is of a type I don't know how to handle
Parents is an array:
0 Gomez
1 Moticia
通过上面的示例可以看到，通过interface{}与type assert的配合，我们就可以解析未知结构的JSON函数了。
生成JSON
若我们要输出JSON数据串，可通过Marshal函数来处理
func Marshal(v interface{})([]byte, error)
例：
// generalJson
package main
import (
"encoding/json"
"fmt"
)
type Server struct {
ServerName string `json:"serverName"`
ServerIP string `json:"serverIP"`
}
type Serverslice struct {
Servers []Server `json:"servers"`
}
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"})
b, err := json.Marshal(s)
if err != nil {
fmt.Println("json err: ", err)
}
fmt.Println(string(b))
}outputs:
{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"}, {"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}
针对JSON的输出，我们在定义struct tag的时候需要注意几点：
字段的tag是“-”，那么这个字段不会输出到JSON
tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中，例如上面例子中的serverName
tag中如果带有“omitempty”选项，那么如果该字段值为空，就不会输出到JSON串中
如果字段类型是bool,string,int,int64等，而tag中带有“,string”选项，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串
// jsontest.go
package main
import (
"encoding/json"
"os"
)
type Server struct {
//ID不会导出到JSON
ID int `json:"-"`
//ServerName的值会进行二次JSON编码
ServerName string `json:"serverName"`
ServerName2 string `json:"serverName2, string"`
//如果ServerIP为空，则不输出到JSON中
ServerIP string `json:"serverIP,omitempty"`
Description string `json:"description,string"`
}
func main() {
s := Server{
ID: 3,
ServerName: `Go "1.0"`,
ServerName2: `Go "1.0"`,
ServerIP: ``,
Description: `描述信息`,
}
b, _ := json.Marshal(s)
os.Stdout.Write(b)
}outputs:
{"serverName":"Go \"1.0\"","serverName2":"Go \"1.0\""}
Marshal函数只有在转换成功的时候才会返回数据，在转换的过程中我们需要注意几点：
JSON对象只支持string作为key,所以要编码一个map,那么必须是map[string]T这种类型（T是Go语言中任意的类型）
Channel,complex和function是不能被编码成JSON的
嵌套的数据时不能编码的，不然会让JSON编码进入死循环
指针在编码的时候会输出指针指向的内容，而空指针会输出null
目前bitly公司开源了一个叫做simplejson的包，在处理未知结构体的JSON时相当方便，地址：https://github.com/bitly/go-simplejson