golang json序列化与反序列化

1、json的序列化

➢介绍.
  json序列化是指，将有key-value结构的数据类型(比如结构体、map、 切片)序列化成json字符串的操作。
➢应用案例
  这里我们介绍一下结构体、map和切片的序列化，其它数据类型的序列化类似。

package main

import (
	"encoding/json"
	"fmt"
)

//定义一个结构体
type Monster struct {
	Name  string
	Age   int
	Sal   float64
	Skill string
}

func testStruct() {
	monster := Monster{
		Name:  "牛魔王",
		Age:   100,
		Sal:   3000.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{}
	a = make(map[string]interface{})
	a["name"] = "tom"
	a["age"] = 29
	a["address"] = "美国"
	//将map序列化
	data, err := json.Marshal(a)
	if err != nil {
		fmt.Printf("序列化错误err=%v\n", err)
	}
	//输出序列化结果
	fmt.Printf("map序列化后=%v\n", string(data))
}

//对切片进行序列化
func testSlice() {
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "Jack"
	m1["age"] = 3
	m1["address"] = "北京"
	slice = append(slice, m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "tom"
	m2["age"] = 10
	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=123.2
	//对切片进行序列化
	data, err := json.Marshal(num1)
	if err != nil {
		fmt.Printf("序列化错误err=%v\n", err)
	}
	//输出序列化结果
	fmt.Printf("num1 序列化后=%v\n", string(data))
}
func main() {
	testStruct()
	testMap()
	testSlice()
	testFloat64()
}

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

//定义一个结构体
type Monster struct {
	Name  string `json:"monster_name"` //反射机制
	Age   int `json:"monster_age"`
	Sal   float64
	Skill string
}

加上tag后

2、json反序列化

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

package main

import (
	"encoding/json"
	"fmt"
)

//定义一个结构体
type Monster struct {
	Name  string
	Age   int
	Sal   float64
	Skill string
}

//将json字符串反序列化成struct
func unmarshalStruct() {
	//说明:str在项目开发中，是通过网络传输获取到..或者是读取文件获取到
	str := " {\"Name\":\"牛魔王\",\"Agel\":500,\"Sal\":10.2,\"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 := " {\"Name\":\"牛魔王\",\"Agel\":500,\"Sal\":10.2}"
	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()
}

➢对上面代码的小结说明
（1)在反序列化一个json字符串时,要确保反序列化后的数据类型和原来序列化前的数据类型一致。
（2)如果json字符串是通过程序获取到的，则不需要再对“转义处理。