Go 语言 JSON 的序列化与反序列化实践
导读
本文使用 Go 原生支持的包,对 JSON 字符串以及 .json
文件进行序列化与反序列化实践。
-
使用到的包是
encoding/json
。详细文档可查看官方中文文档,链接为: https://studygolang.com/pkgdoc -
本文中所有代码块的 Go 代码均经过运行测试,可以直接复制运行。
-
请留意代码块中的注释,注释中有表示出一些非常重要的细节!
文章目录
一. 简述序列化与反序列化
序列化(Serialization),有的人也称之为反解析。指的是将对象的状态信息转换为可以存储或传输的形式的过程。
而反序列化,有的人成为解析。指的就是序列化的逆过程。
图1. 序列化与反序列化
例如,定义如下结构体 book,我们可以创建一个实体对象,bookObj,此时 bookObj 是一个在程序中的实体对象。若我要存储这个对象,或者将其通过 HTTP 进行传输,我就需要将其进行序列化为可以进行存储或者传输的文件形式,例如 json。
package main
import (
"fmt"
"time"
)
type Book struct {
Name string
Author string
PublishTime time.Time
}
func main() {
bookObj := &Book{
Name: "Go 语言基础入门",
Author: "fxtack",
PublishTime: time.Now(),
}
fmt.Println(bookObj)
}
若进行序列化,序列化后的 bookObj 对象的 JSON 格式为(注意,结构体字段名与 JSON 中的字段名并不是完全相等的):
{
"name": "Go 语言基础入门",
"author": "fxtack",
"publishTime": "2021-07-03T18:23:57.7451495+08:00"
}
这样我就可以通过存储和传输 json 来实现对 bookObj 对象的存储和传输了。
相应的,如果需要这个对象而读取 json 文件,或者传输的接收者收到这个对象的 json 并打算使用这个对象时,就需要通过反序列化,将其从 json 的格式重新转化为程序中的对象。
二. JSON 的序列化
1. 序列化简单示例
先写一个简单测试,示例如何使用 Go 进行序列化。代码如下:
package main
import (
"encoding/json"
"fmt"
"time"
)
type Book struct {
Name string
Author string
PublishTime time.Time
}
func main() {
bookObj := &Book{
Name: "Go 语言基础入门",
Author: "fxtack",
PublishTime: time.Now(),
}
// 使用 encoding/json 包进行序列化
// json.Marshal 序列化函数可以接受对象实例也可以接受对象指针
// 返回 byte[] 与 error,使用 error 可以对序列化是否成功进行判断,此处省略
jsonBytes, _ := json.Marshal(bookObj)
// 以字符串形式将序列化结果输出
fmt.Println(string(jsonBytes))
}
结果如下,已经符合 JSON 格式,序列化成功。
{"Name":"Go 语言基础入门","Author":"fxtack","PublishTime":"2021-07-03T19:00:04.1716455+08:00"}
注意
结构体中每个字段首字母必须是大写,这样各个字段才是可被访问的,也才能顺利完成序列化。下文中的反序列化也同理。
我们可以注意到,虽然输出的字符串已经符合 JSON 的语法要求,但其格式还不够规范。Go 中还有一个序列化函数为 json.MarshalIndent
可以输出更好的格式。使用如下:
package main
import (
"encoding/json"
"fmt"
"time"
)
type Book struct {
Name string
Author string
PublishTime time.Time
}
func main() {
bookObj := &Book{
Name: "Go 语言基础入门",
Author: "fxtack",
PublishTime: time.Now(),
}
// 注意 json.MarshalIndent 的参数多了两个
jsonBytes, _ := json.MarshalIndent(bookObj, "", "\t")
fmt.Println(string(jsonBytes))
}
此时输出为规范的 JSON 内容,如下:
{
"Name": "Go 语言基础入门",
"Author": "fxtack",
"PublishTime": "2021-07-03T19:07:19.8107909+08:00"
}
此时我们可以看到 JSON 内容中的字段与结构体中的字段名是完全相同的。在本文第一章中展示的 JSON 内容则是首字母小写的驼峰命名法。
若要将结构体字段映射到新的名称,可以在结构体中使用 json 标签来实现。
package main
import (
"encoding/json"
"fmt"
"time"
)
type Book struct {
// 注意,每个字段都使用了对 json 标签,标签中的内容将会映射为 JSON 的字段名
Name string `json:"name"`
Author string `json:"author"`
PublishTime time.Time `json:"publishTime"`
}
func main() {
bookObj := &Book{
Name: "Go 语言基础入门",
Author: "fxtack",
PublishTime: time.Now(),
}
jsonBytes, _ := json.MarshalIndent(bookObj, "", "\t")
fmt.Println(string(jsonBytes))
}
结果如下:
{
"name": "Go 语言基础入门",
"author": "fxtack",
"publishTime": "2021-07-04T15:18:45.9907985+08:00"
}
如果需要,可以通过 json 标签映射为任意需要的名称。
2. 序列化完整代码
接下来考虑完整的过程,将对象序列化为 .json
文件,其流程如下:
代码如下:
package main
import (
"encoding/json"
"log"
"os"
"time"
)
type Book struct {
// 使用 json 标签
Name string `json:"name"`
Author string `json:"author"`
PublishTime time.Time `json:"publishTime"`
}
func main() {
bookObj := &Book{
Name: "Go 语言基础入门",
Author: "fxtack",
PublishTime: time.Now(),
}
// 调用序列化函数,序列化结果存储到 ./book.json
WriteJson("./book.json", bookObj)
}
// 序列化为 .json 文件函数
// filePath 为存储到的路径,ref 为需要序列化的对象或其应用
func WriteJson(filePath string, ref interface{}) {
// 判断提供的路径文件是否存在,避免直接覆盖已有的文件
f, err := os.Stat(filePath)
if (err == nil || os.IsExist(err)) && !f.IsDir(){
log.Println("文件已经存在或存在同名文件夹")
return
}
// 创建 .json 文件
file, err := os.Create(filePath)
if err != nil {log.Println("文件创建失败")}
defer file.Close()
// 序列化
json, err := json.MarshalIndent(ref, "", "\t")
if err != nil {
log.Println("序列化失败")
}
// 写入 .json 文件
file.Write(json)
}
运行后会在 Go 模块下多出一个 book.json
的文件,说明序列化成功。
二. JSON 的反序列化
1. 反序列化简单示例
先写一个简单测试,演示 Go 是如何完成 JSON 的反序列化。
这里用我们在上文中序列化得到的 JSON 字符串来做演示。
package main
import (
"encoding/json"
"fmt"
"time"
)
type Book struct {
// 注意,使用了 json 标签,则 JSON 内容的字段名必须与 json 标签的值一致才能被解析
Name string `json:"name"`
Author string `json:"author"`
PublishTime time.Time `json:"publishTime"`
}
func main() {
// 序列化示例中得到的 JSON 字符串
jsonStr := "{\"name\":\"Go 语言基础入门\",\"author\":\"fxtack\",\"publishTime\":" +
"\"2021-07-03T19:00:04.1716455+08:00\"}"
// 声明一个空的 book 来接受结果
var bookObj Book
// 注意!反序列化函数 json.Unmarshal 的参数一个是 JSON 字符串的字节切片
// 一个是用于接受反序列化结果的对象引用。或者说传入的对象必须是可寻址的
json.Unmarshal([]byte(jsonStr), &bookObj)
fmt.Printf("书名为 《%s》, 作者是 %s, 发布时间为 %s",bookObj.Name, bookObj.Author, bookObj.PublishTime)
}
运行结果如下。
书名为 《Go 语言基础入门》, 作者是 fxtack, 发布时间为 2021-07-03 19:00:04.1716455 +0800 CST
结果输出是通过 bookObj 对象引用其属性来完成的,其字段不是空值,可见序列化完成。
注意
- 如果存在无法匹配到结构体字段的 JSON 字段,Go 反序列化时会无视这些字段。
- 如果结构体字段在 JSON 中没有字段与之匹配,Go 反序列化时也会无视这些字段,其值为结构体字段类型的默认值。
2. 反序列化完整代码
接下来考虑完整的过程,将上文中序列化的 .json
文件进行读取,实现反序列化,其流程如下:
代码如下:
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"os"
"time"
)
type Book struct {
Name string `json:"name"`
Author string `json:"author"`
PublishTime time.Time `json:"publishTime"`
}
func main() {
var bookObj Book
// 调用反序列化函数对上文中生成的 ./book.json 文件进行读取与反序列化
ReadJson("./book.json", &bookObj)
fmt.Printf("书名为 《%s》, 作者是 %s, 发布时间为 %s",bookObj.Name, bookObj.Author, bookObj.PublishTime)
}
func ReadJson(filePath string, ref interface{}) {
// 检查文件是否不存在,或者存在的是同名文件夹
f, err := os.Stat(filePath)
if err != nil && os.IsNotExist(err) || f.IsDir(){
log.Println("文件不存在")
return
}
// 读取文件内容
data, err := ioutil.ReadFile(filePath)
if err != nil {
log.Println("io 错误")
return
}
// 反序列化
err = json.Unmarshal(data, ref)
if err != nil {
log.Println("反序列化失败")
return
}
}
其结果与测试示例结果一致,则反序列化成功。
三. 序列化与反序列化中的多种类型
上文的例子中,我们仅涉及到了两种类型 string
类型和 time.Time
。接下来通过一个例子,演示多种类型:整型、浮点数、布尔值、数组(或切片)、自定义结构体,在序列化与反序列化中的转换情况。
我们先从如下 library.json 文件考虑如何反序列化。
{
"name": "Shanghai library",
"location" : "Shanghai",
"isPrivate": false,
"score": 4.6,
"date": {
"open": "0001-01-01T08:15:00.000000+08:00",
"close" : "0001-01-01T18:00:00.000000+08:00"
},
"bookInfo" : {
"number": 1000,
"bookList": [
{
"name": "Java programing",
"author": "author1",
"publishTime": "2020-07-31T14:27:10.035542+08:00"
},{
"name": "Go programing",
"author": "author2",
"publishTime" : "2020-07-31T14:27:10.035542+08:00"
},{
"name": "Go network programing",
"author": "author2",
"publishTime" : "2020-07-31T14:27:10.035542+08:00"
}
]
}
}
JSON 字段与其对应的 Go 类型情况如下表:
字段名 | 对应 Go 类型 | 字段名 | 对应 Go 类型 | 字段名 | 对应 Go 类型 | 字段名 | 对应 Go 类型 |
---|---|---|---|---|---|---|---|
name | string | ||||||
location | string | ||||||
isPrivate | bool | ||||||
score | float64 | ||||||
data | Data(自定义结构体) | open | time.Time | ||||
close | time.Time | ||||||
bookInfo | BookInfo(自定义结构体) | number | int | ||||
bookList | []Book(自定义结构体数组切片) | - | Book(自定义结构体) | name | string | ||
author | string | ||||||
publishTime | string | ||||||
- | Book(自定义结构体) | name | string | ||||
author | string | ||||||
publishTime | string | ||||||
- | Book(自定义结构体) | name | string | ||||
author | string | ||||||
publishTime | string |
可见其中囊括了大部分常用的类型与情况。接下来为了能够反序列化该 JSON 文件。要在Go 中用结构体对其进行建模,并读取文件进行反序列化。
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"os"
"time"
)
// 整个 JSON 文件对应的结构体
type Library struct {
Name string `json:"name"`
Location string `json:"location"`
IsPrivate bool `json:"isPrivate"`
Score float64 `json:"score"`
Date Date `json:"date"`
BookInfo BookInfo `json:"bookInfo"`
}
// date 字段对应的结构体
type Date struct {
Open time.Time `json:"open"`
Close time.Time `json:"close"`
}
// bookInfo 字段对应的结构体
type BookInfo struct {
Number int `json:"number"`
BookList []Book `json:"bookList"`
}
// book 字段对应的结构体
type Book struct {
Name string `json:"name"`
Author string `json:"author"`
PublishTime time.Time `json:"publishTime"`
}
func main() {
var library Library
ReadJson("./library.json", &library)
fmt.Println(library)
library.BookInfo.BookList[1].PublishTime = time.Now()
WriteJson("./library_change_book.json", &library)
}
// 读入 JSON 文件,实现反序列化
func ReadJson(filePath string, ref interface{}) {
f, err := os.Stat(filePath)
if err != nil && os.IsNotExist(err) || f.IsDir(){
log.Println("文件不存在")
return
}
data, err := ioutil.ReadFile(filePath)
if err != nil {
log.Println("io 错误")
return
}
err = json.Unmarshal(data, ref)
if err != nil {
log.Println("反序列化失败")
return
}
}
// 输出 JSON 文件,实现序列化
func WriteJson(filePath string, ref interface{}) {
f, err := os.Stat(filePath)
if (err == nil || os.IsExist(err)) && !f.IsDir(){
log.Println("文件已经存在或存在同名文件夹")
return
}
file, err := os.Create(filePath)
if err != nil {log.Println("文件创建失败")}
defer file.Close()
json, err := json.MarshalIndent(ref, "", "\t")
if err != nil {
log.Println("序列化失败")
}
file.Write(json)
}
上述代码已经给出了反序列化函数和序列化函数,并读取 ./library.json
反序列化得到 library
对象并输出。结果为:
{Shanghai library Shanghai false 4.6 {0001-01-01 08:15:00 +0800 CST 0001-01-01 18:00:00 +0800 CST} {1000 [{Java programing author1 2020-07-31 14:27:10.035542 +0800 CST} {Go programing author2 2020-07-31 14:27:10.035542 +0800 CST} {Go network programing author2 2020-07-31 14:27:10.035542 +0800 CST}]}}
再修改图书馆的第二本书的发布日期为当天日期,并序列化为新的文件./library_change_book.json
。
执行完成,序列化与反序列化都成功了。
后续
本文对 JSON 的序列化与反序列化进行了探讨与实践。
后续将会继续更新 Go 对 xml 的序列化与反序列化实践教程。
欢迎关注,将会持续更新。
其他相关文章
文章名称 | 更新时间 |
---|---|
Go 语言 JSON 的序列化与反序列化实践 | 2021-7-30 |
Go 语言 XML 的序列化与反序列化实践 | 2021-9-27 |