Json(Javascript Object Nanotation)是一种数据交换格式，常用于前后端数据传输。任意一端将数据转换成json字符串，另一端再将该字符串解析成相应的数据结构，如string类型，strcut对象等。go语言本身为我们提供了json的工具包encoding/json。
1 序列化为json字符串
1.1 Marshal
package main
import (
"encoding/json"
"fmt"
"os"
)
func main ( ) {
type ColorGroup struct {
ID int
Name string `json:"name"`
Colors [ ] string
note string
}
group := ColorGroup {
ID : 1 ,
Name : "Reds" ,
Colors : [ ] string { "Crimson" , "Red" , "Ruby" , "Maroon" } ,
}
b , err := json. Marshal ( group )
if err != nil {
fmt. Println ( "error:" , err )
}
os. Stdout . Write ( b )
}
结果输出：
{"ID":1,"name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
1.2 序列化备注
- 只有首字母是大写的成员才可以序列化为JSON
只有可导出成员（变量首字母大写）才可以序列化为json。因成员变量note是不可导出的，故无法转成json。 - 序列化为JSON的字段名称可以指定
如果变量打上了json标签，如Name旁边的json:"name"，那么转化成的json key就用该标签name而不是Name。
否则取变量名作为key，如ID，Colors。 - 可以序列化为JSON的类型和限制
- 基本数据类型和普通的结构体都可以序列化，如
bool类型也是可以直接转换为json的value值。循环的数据结构不能序列化为JSON，它会导致marshal陷入死循环。 -
channel，complex以及函数不能被编码json字符串。
- 指针变量编码时自动转换为它所指向的值
指针变量编码时自动转换为它所指向的值，与直接定义为结构体对象类型效果一样，只不过指针更快，且能节省内存空间。 - 对象序列化为json后就成为纯粹的字符串。
- 包含通用类型的对象序列化
成员变量都是已知的类型，只能接收指定的类型，比如string类型的Name只能赋值string类型的数据。
有时为了通用性或使代码简洁，我们希望有一种类型可以接受各种类型的数据，并序列化为json，就需要使用interface{}类型。无论是string，int，bool，还是指针类型等，都可赋值给interface{}类型，且正常编码，效果与前面的例子一样。
备注：interface{}类型其实是个空接口，即没有方法的接口。go的每一种类型都实现了该接口。因此，任何其他类型的数据都可以赋值给interface{}类型。 - 序列化为JSON字符串支持切片类型
切片类型的数据结构可以序列化为JSON字符串。
2 反序列化
2.1 Unmarshal
package main
import (
"encoding/json"
"fmt"
)
func main ( ) {
var jsonBlob = [ ] byte ( ` [
{ "Name" : "Platypus" , "Order" : "Monotremata" } ,
{ "Name" : "Quoll" , "Order" : "Dasyuromorphia" }
] ` )
type Animal struct {
Name string
Order string
}
var animals [ ] Animal
err := json. Unmarshal ( jsonBlob , & animals )
if err != nil {
fmt. Println ( "error:" , err )
}
fmt. Printf ( "%+v" , animals )
}
结果输出：
[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
2.2 RawMeaage
package main
import (
"encoding/json"
"fmt"
"log"
)
func main ( ) {
type Color struct {
Space string
Point json. RawMessage // delay parsing until we know the color space
}
type RGB struct {
R uint8
G uint8
B uint8
}
type YCbCr struct {
Y uint8
Cb int8
Cr int8
}
var j = [ ] byte ( ` [
{ "Space" : "YCbCr" , "Point" : { "Y" : 255 , "Cb" : 0 , "Cr" : -10 } } ,
{ "Space" : "RGB" , "Point" : { "R" : 98 , "G" : 218 , "B" : 255 } }
] ` )
var colors [ ] Color
err := json. Unmarshal ( j , & colors )
if err != nil {
[log ](http://www.opengroup.org/onlinepubs/009695399/functions/log.html). Fatalln ( "error:" , err )
}
for _ , c := range colors {
var dst interface { }
switch c. Space {
case "RGB" :
dst = new ( RGB )
case "YCbCr" :
dst = new ( YCbCr )
}
err := json. Unmarshal ( c. Point , dst )
if err != nil {
[log ](http://www.opengroup.org/onlinepubs/009695399/functions/log.html). Fatalln ( "error:" , err )
}
fmt. Println ( c. Space , dst )
}
}
输出结果：
YCbCr &{255 0 -10}
RGB &{98 218 255}
2.3 Decoder
package main
import (
"encoding/json"
"fmt"
"io"
"log"
"strings"
)
func main ( ) {
const jsonStream = `
{ "Name" : "Ed" , "Text" : "Knock knock." }
{ "Name" : "Sam" , "Text" : "Who's there?" }
{ "Name" : "Ed" , "Text" : "Go fmt." }
{ "Name" : "Sam" , "Text" : "Go fmt who?" }
{ "Name" : "Ed" , "Text" : "Go fmt yourself!" }
`
type Message struct {
Name , Text string
}
dec := json. NewDecoder ( strings. NewReader ( jsonStream ) )
for {
var m Message
if err := dec. Decode ( & m ) ; err == io. EOF {
break
} else if err != nil {
[log ](http://www.opengroup.org/onlinepubs/009695399/functions/log.html). Fatal ( err )
}
fmt. Printf ( "%s: %s \n " , m. Name , m. Text )
}
}
输出结果：
Ed: Knock knock.
Sam: Who's there?
Ed: Go fmt.
Sam: Go fmt who?
Ed: Go fmt yourself!
2.4 反序列化备注
- json字符串解析时，需要一个接收体接收解析后的数据，且Unmarshal时接收体必须传递指针。否则解析虽不报错，但数据无法赋值到接收体中。
- json字符串key和对象字段的匹配规则
解析时，接收体可自行定义。json串中的key自动在接收体中寻找匹配的字段进行赋值。匹配规则是：
- 先查找与key一样的json标签，找到则赋值给该标签对应的变量(如Name)。
- 没有json标签的，就从上往下依次查找变量名与key一样的变量，如Age。或者变量名忽略大小写后与key一样的变量，如HIgh，Class。第一个匹配的就赋值，后面就算有匹配的也忽略。
- 可解析的变量必须是可导出的，即首字母大写。不可导出的变量无法被解析（即使json串中有对应key的k-v，解析后其值仍为nil,即空值）。
- 当接收体中存在json串中匹配不了的项时，解析会自动忽略该项，该项仍保留原值。如没有初始值，保留空值nil。
- interface{}类型的变量，如果解析时没有明确指定字段的类型，可能得不到自己期望的数据结构。例如：解析时不指定变量的具体类型(定义为interface{}类型)，json自动将value为复合结构的数据解析为map[string]interface{}类型的项。
- interface{}类型变量的类型(
reflect.TypeOf(value))都为nil，就是没有具体类型，这是空接口（interface{}类型）的特点。 - 简单数据如基本数据类型的数据只进行一次json解析。
复合数据如切片、数据结构等数据，可进行二次甚至多次json解析的，因为它的value也是个可被解析的独立json。对于”复合数据”，如果接收体中的项被声明为interface{}类型，go都会默认解析成map[string]interface{}类型。如果我们想直接解析到期望的数据结构对象中，可以将接收体对应的项定义为具体的struct类型。 - 保留反序列化中的
interface{}类型
如果不想指定变量为具体的类型，仍想保留interface{}类型，但又希望该变量可以解析到对象中，可以将该变量定义为json.RawMessage类型。如此做之后在接收体中，被声明为json.RawMessage类型的变量在json解析时，变量值仍保留json的原值，即未被自动解析为map[string]interface{}类型。我们可以对该变量进行二次json解析，因为其值仍是个独立且可解析的完整json串。我们只需再定义一个新的接收体(具体的结构体)即可。
参考
- Package json
- JSON and Go
- Go的json解析：Marshal与Unmarshal