文章目录
- 序列化
- 1. 结构体序列化
- 2. 字典序列化
- 3. 切片序列化
- 反序列化
- 1. 明确知道 JSON 格式
- 2. 无法确定 JSON 格式
- 3. JSON 格式字节流来自一个 Reader
- 参考内容
Go 语言中的
encoding/json 库提供了复杂的将 Go 中各种类型与JSON格式之间转换的功能， 我们主要使用以下几个功能：
- 将一个切片、结构体或字典序列化成 JSON 格式的字节流【字符串】。
- 将一个 JSON 格式的字节流【字符串】反序列化成一个切片、结构体或字典。
序列化
序列化使用 json 库中的Marshal函数：
func Marshal(v interface{}) ([]byte, error)1. 结构体序列化
比如使用以下的结构体表示一部电影：
type Movie struct {
Title string
Year int `json:"released"`
Color bool `json:"color,omitempty"`
Actors []string
}定义里域类型后面跟的字符串 json:"released"和json:"color,omitempty，称为 field tags【域标签】，它告诉 json 库在执行序列化时的一些规则：
-
json:"released"使得在序列化后对应的名字为"released"，而不是"Year"。 -
json:"color,omitempty"使得如果 Color 成员的值为false，那么就忽略它，不对它进行序列化。
官方文档中关于 field tags 的示例如下：
// Field appears in JSON as key "myName".
Field int `json:"myName"`
// Field appears in JSON as key "myName" and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `json:"myName,omitempty"`
// Field appears in JSON as key "Field" (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `json:",omitempty"`
// Field is ignored by this package.
Field int `json:"-"`
// Field appears in JSON as key "-".
Field int `json:"-,"`没有 field tags 时进行序列化的一些规则：
- 如果结构体域的名字不是以大写字母开头，则不对它进行序列化。
- 如果结构体域的名字是以大写字母开头，则序列化后的名字就是域的名字。
进行序列化的代码如下：
movie := Movie{
Title: "Casablanca",
Year: 1942,
Color: false,
Actors: []string{"Humphrey Bogart", "Ingrid Bergman"},
}
data, err := json.Marshal(movie)
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)输出：
{"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingrid Bergman"]}2. 字典序列化
一个字典要想序列化成 JSON 格式，它的 key 必须是字符串，它的 value 也必须能够被序列化。
以下是一个例子：
info := map[string]int{
"width": 1280,
"height": 720,
}
data, err := json.MarshalIndent(info, "", " ")
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)输出：
{
"height": 720,
"width": 1280
}这里我们使用MarshalIndent函数，使得输出后的 JSON 格式更易阅读。序列化后的名字就是字典中 key 的名称。
3. 切片序列化
直接看一个例子：
type Movie struct {
Title string
Year int `json:"released"`
Color bool `json:"color,omitempty"`
Actors []string
}
var movies = []Movie{
{
Title: "Casablanca",
Year: 1942,
Color: false,
Actors: []string{"Humphrey Bogart", "Ingrid Bergman"},
},
{
Title: "Cool Hand Luke",
Year: 1967,
Color: true,
Actors: []string{"Paul Newman"},
},
{
Title: "Bullitt",
Year: 1968,
Color: true,
Actors: []string{"Steve McQueen", "Jacqueline Bisset"},
},
}
data, err := json.MarshalIndent(movies, "", " ")
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)输出：
[
{
"Title": "Casablanca",
"released": 1942,
"Actors": [
"Humphrey Bogart",
"Ingrid Bergman"
]
},
{
"Title": "Cool Hand Luke",
"released": 1967,
"color": true,
"Actors": [
"Paul Newman"
]
},
{
"Title": "Bullitt",
"released": 1968,
"color": true,
"Actors": [
"Steve McQueen",
"Jacqueline Bisset"
]
}
]反序列化
反序列化使用Unmarshal函数：
func Unmarshal(data []byte, v interface{}) error1. 明确知道 JSON 格式
我们要先将 JSON 格式表示为一个确定的类型。
1.如下的 JSON 格式是一个 JSON 对象：
{
"name": "Awesome 4K",
"resolutions": [
{
"width": 1280,
"height": 720
},
{
"width": 1920,
"height": 1080
},
{
"width": 3840,
"height": 2160
}
]
}我们可以用如下结构体来表示它：
struct {
Name string
Resolutions []struct {
Width int
Height int
}
}将 JSON 对象反序列化成结构体同样也有一些规则。比如，对于名字 “width”，Unmarshal会按如下的顺序查找结构体中的域：
- 一个可导出的域，并且带有“Width” 标签。
- 一个可导出的域，名字是"Width"。
- 一个可导出的域，名字是"WIDTH"或"WIdth"或其他不区分大小写能匹配"Width"的名字。
如果找不到结构体中匹配的域，则不对它进行反序列化。
2.如下的 JSON 格式也是一个 JSON 对象：
{
"height": 720,
"width": 1280
}也可以使用map[string]int，也就是字典来表示。
3.如下的 JSON 格式是一个 JSON 数组：
[
{
"width": 1280,
"height": 720
},
{
"width": 1920,
"height": 1080
},
{
"width": 3840,
"height": 2160
}
]可以使用切片[]map[string]int来表示。
不管怎样，一个确定的JSON格式总是可以使用切片、结构体或字典来表示，具体表示成什么根据具体的 JSON 格式灵活决定。
之后就可以使用Unmarshal执行反序列化了：
var jsonBlob = []byte(`
[
{
"width": 1280,
"height": 720
},
{
"width": 1920,
"height": 1080,
},
{
"width": 3840,
"height": 2160
}
]
`)
di := []map[string]int{}
err = json.Unmarshal(jsonBlob, &di)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v\n", di)输出
[map[height:720 width:1280] map[height:1080 width:1920] map[height:2160 width:3840]]2. 无法确定 JSON 格式
无法确定的格式可以直接使用interface{}类型来表示:
- 如果是JSON对象，则反序列化时 json 库会使用
map[string]interface{}类型来表示它。 - 如果是JSON数组，则会使用
[]interface{}类型来表示它。
至于interface{}对应的具体类型是什么，就需要使用类型断言确定了。
具体看一个示例：
package main
import (
"encoding/json"
"fmt"
)
func main() {
var jsonBlob = []byte(`
{
"name": "Awesome 4K",
"price": 1999.9,
"resolutions": [
{
"width": 1280,
"height": 720
},
{
"width": 1920,
"height": 1080
},
{
"width": 3840,
"height": 2160
}
]
}
`)
var d interface{}
err := json.Unmarshal(jsonBlob, &d)
if err != nil {
fmt.Println("error:", err)
}
fmt.Println(d)
m := d.(map[string]interface{})
for k, v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k, "is string", 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")
}
}
}输出：
map[name:Awesome 4K price:1999.9 resolutions:[map[height:720 width:1280] map[height:1080 width:1920] map[height:2160 width:3840]]]
resolutions is an array:
0 map[height:720 width:1280]
1 map[height:1080 width:1920]
2 map[height:2160 width:3840]
name is string Awesome 4K
price is float64 1999.93. JSON 格式字节流来自一个 Reader
直接看官方的一个示例，如何处理 Reader 中包含多个JSON 字节流的情形：
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.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!
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
