json解析：marshal和unmarshal

Go 使用 encoding/json 包的 marshal 和 unmarshal 实现 json 数据的编解码。分别记录如下：

1. marshal

定义结构体：

type OCP struct {
Name string `json:"name"`
ImageRegistry *ImageRegistry `json:"imageRegistry"`
Status string `json:"status"`
Events []string `json:"events"`
id *int
}
type ImageRegistry struct {
Addr string `json:"addr"`
User string `json:"user"`
Password string `json:"password"`
}


将结构体 OCP 类型值编码成 json 格式：

func main() {
imageRegistry := ImageRegistry{
Addr: "x.x.x.x",
User: "admin",
Password: "admin",
}
ocp := OCP{
Name: "lubanseven",
ImageRegistry: &imageRegistry,
Status: "running",
Events: []string{"normal", "normal", "normal"},
}
data, err := json.Marshal(ocp)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(data))
}


输出：

{"name":"lubanseven","imageRegistry":{"addr":"x.x.x.x","user":"admin","password":"admin"},"status":"running","events":["normal","normal","normal"]}


从输出可以看出：

1. 结构体中以小写字母开头的类型(id)不会被编码。


2. 结构体中指针类型在编码时将转换为指针所指向的值。

更多编码规则可看 JSON and Go

2. unmarshal

类似的将 data 解码为结构体类型 OCP 的值：

var lubanseven OCP
err = json.Unmarshal(data, &lubanseven)
if err != nil {
fmt.Println(err)
}
fmt.Println(lubanseven)


输出：

{lubanseven 0xc00020e360 running [normal normal normal] }


从输出可以看出：

1. 指针类型的值在解码时将转换为值的地址。


2. 对于无法解码的值，将转换为该值的零值，如指针类型变量 id 解码为 nil。

更多编码规则可看 JSON and Go

对于第二点，将 id 类型定义成 int，查看解码后的结构体值：

type OCP struct {
Name string `json:"name"`
ImageRegistry *ImageRegistry `json:"imageRegistry"`
Status string `json:"status"`
Events []string `json:"events"`
id int
}


输出：

{lubanseven 0xc0000cc4b0 running [normal normal normal] 0}


这点在解码的时候要注意。

上例中解码的结构体类型是已知的，如果结构体未知该如何确定结构体类型呢？这在实际场景中是会发生的，比如传输的数据流，事先不知道其结构体类型。

可以通过类型断言的方式，确定结构体类型，如下：

var lubanunknown interface{}
err = json.Unmarshal(data, &lubanunknown)
if err != nil {
fmt.Println(err)
}
fmt.Println(lubanunknown)
if value, ok := lubanunknown.(map[string]interface{}); ok {
fmt.Println(value)
}


输出：

map[events:[normal normal normal] imageRegistry:map[addr:x.x.x.x password:admin user:admin] name:lubanseven status:running]
map[events:[normal normal normal] imageRegistry:map[addr:x.x.x.x password:admin user:admin] name:lubanseven status:running]


输出类型是 map[string]interface{}，key 是 string，value 是 interface{}，可以对 value 进行类型断言确定 interface{} 的实质类型(直接看输出也能看出来...)：

value := lubanunknown.(map[string]interface{})
for k, v := range value {
switch vv := v.(type) {
case int:
fmt.Println(k, "is int: ", vv)
case string:
fmt.Println(k, "is string: ", vv)
case []interface{}:
fmt.Println(k, "is slice: ", vv)
for _, v := range vv {
fmt.Println(v)
}
case map[string]interface{}:
fmt.Println(k, "is struct: ", vv)
default:
fmt.Println(k, "unexpect type of ", reflect.TypeOf(vv))
}
}


输出：

imageRegistry is struct: map[addr:x.x.x.x password:admin user:admin]
status is string: running
events is slice: [normal normal normal]
normal
normal
normal
name is string: lubanseven


3. 数据流的 json 编解码

对数据流的编解码，如下：

package main
import (
"encoding/json"
"log"
"os"
)
func main() {
dec := json.NewDecoder(os.Stdin)
enc := json.NewEncoder(os.Stdout)
for {
var v map[string]interface{}
if err := dec.Decode(&v); err != nil {
log.Println(err)
return
}
for k := range v {
if k != "Name" {
delete(v, k)
}
}
if err := enc.Encode(&v); err != nil {
log.Println(err)
}
}
}


示例来自 JSON and Go

运行示例：

$ go run main.go
{"name":"lubanseven","imageRegistry":{"addr":"x.x.x.x","user":"admin","password":"admin"},"status":"running","events":["normal","normal","normal"]}
{}
{"Name":"lubanseven","imageRegistry":{"addr":"x.x.x.x","user":"admin","password":"admin"},"status":"running","events":["normal","normal","normal"]}
{"Name":"lubanseven"}