随笔- 166 文章- 2 评论- 2 阅读- 15万

Golang-Json序列化和反序列化

json 的序列化介绍

json 序列化是指，将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成 json 字符串的操作。

应用案例

这里我们介绍一下结构体、map 和切片的序列化，其它数据类型的序列化类似。

package main 
import (
    "fmt"
    "encoding/json"
)
     
//定义一个结构体
type Monster struct {
    Name string 
    Age int 
    Birthday string 
    Sal float64 
    Skill string
}
     
func testStruct() {
    //演示
    monster := Monster{
        Name :"牛魔王", Age : 500,
        Birthday : "2011-11-11",
        Sal : 8000.0,
        Skill : "牛魔拳",
    }
    //将 monster 序列化
    data, err := json.Marshal(&monster) 
    if err != nil {
        fmt.Printf("序列号错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("monster 序列化后=%v\n", string(data))
     
}
//将 map 进行序列化
func testMap() {
    //定义一个 map
    var a map[string]interface{}
    //使用 map,需要 make
    a = make(map[string]interface{}) a["name"] = "红孩儿"
    a["age"] = 30
    a["address"] = "洪崖洞"
     
    //将 a 这个 map 进行序列化
    //将 monster 序列化
    data, err := json.Marshal(a) 
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("a map  序列化后=%v\n", string(data))
 
}
//演示对切片进行序列化, 我们这个切片 []map[string]interface{} 
func testSlice() {
    var slice []map[string]interface{} 
    var m1 map[string]interface{}
    //使用 map 前，需要先 make
    m1 = make(map[string]interface{}) m1["name"] = "jack"
    m1["age"] = "7"
    m1["address"] = "北京"
    slice = append(slice, m1)
     
    var m2 map[string]interface{}
    //使用 map 前，需要先 make
    m2 = make(map[string]interface{})
    m2["name"] = "tom"
    m2["age"] = "20"
    m2["address"] = [2]string{"墨西哥","夏威夷"} 
    slice = append(slice, m2)
 
    //将切片进行序列化操作
    data, err := json.Marshal(slice) 
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("slice 序列化后=%v\n", string(data))
 
}
//对基本数据类型序列化，对基本数据类型进行序列化意义不大
func testFloat64() {
    var num1 float64 = 2345.67
 
    //对 num1 进行序列化
    data, err := json.Marshal(num1) 
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("num1 序列化后=%v\n", string(data))
}
 
func main() {
    //演示将结构体, map , 切片进行序列号
    testStruct() testMap()
    testSlice()//演示对切片的序列化
    testFloat64()//演示对基本数据类型的序列化
}
    

注意事项
　　对于结构体的序列化，如果我们希望序列化后的key 的名字，又我们自己重新制定，那么可以给struct指定一个 tag 标签.
　　

　　序列化后：
　　{"monster_name":"牛魔王","monster_age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}

json 的反序列化基本介绍

　　json 反序列化是指，将 json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作
　　应用案例
　　这里我们介绍一下将 json 字符串反序列化成结构体、map 和切片代码演示：

package main 
import (
    "fmt"
    "encoding/json"
)
     
//定义一个结构体
type Monster struct {
    Name string Age int
    Birthday string //....
    Sal float64 Skill string
}
     
//演示将 json 字符串，反序列化成 struct
func unmarshalStruct() {
    //说明 str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
    str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"
     
    //定义一个 Monster 实例
    var monster Monster
    err := json.Unmarshal([]byte(str), &monster) 
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化后 monster=%v monster.Name=%v \n", monster, monster.Name)
     
}
//演示将 json 字符串，反序列化成 map
func unmarshalMap() {
    str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
     
    //定义一个 map
    var a map[string]interface{}
     
    //反序列化
    //注意：反序列化 map,不需要 make,因为 make 操作被封装到 Unmarshal 函数
    err := json.Unmarshal([]byte(str), &a) 
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化后 a=%v\n", a)
     
}
//演示将 json 字符串，反序列化成切片
func unmarshalSlice() {
    str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," +
    "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
     
    //定义一个 slice
    var slice []map[string]interface{}
    //反序列化，不需要 make,因为 make 操作被封装到 Unmarshal 函数
    err := json.Unmarshal([]byte(str), &slice) 
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化后 slice=%v\n", slice)
}
     
func main() {
     
    unmarshalStruct() 
    unmarshalMap() 
    unmarshalSlice()
}