Go 语言 序列化、反序列化的使用

Go 语言 序列化、反序列化的使用

一、结构体的操作:

1. 结构体序列化：

package main

import (
	"encoding/json"
	"fmt"
)

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

// 演示结构体进行序列化
func testStruct () {
	monster := Monster{Name:"铁牛", Age: 18, Birthday: "2020-02-02", Sal: 1.00}
	// 将结构体Monster进行序列化
	data, err := json.Marshal(&monster)
	if err != nil{
		fmt.Printf("序列化错误 err=%v", err)
	}
	// 输出序列化后的结果
	fmt.Printf("monster 序列化后的=%v", string(data))  // 返回的是[]byte切片, 需要转换string类型
}

func main()  {
	// 演示将结构体进行序列化
	testStruct()
}

使用json.Marshal(*point)：

1. 参数是指针类型；
2. 返回值是[]byte切片, 需要转换string;

序列化时，给字段起别名的用法：

// 在定义结构体的时候, 需要进行 反射机制
type Monster struct {
	Name string `json:"monster_name"`  // 反射机制
	Age int `json:"monster_age"`
	Birthday string `json:"birthday"`
	Sal float64
}

注意：格式，严格匹配, 不能有多余的空格之类

2.结构体反序列化：

package main

import (
	"encoding/json"
	"fmt"
)

// 定义一个结构体
type Monster struct {
	Name string
	Age int
	Birthday string
	Sal float64
}
// 将json 字符串, 反序列化struct
func unmarshalStruct () {
	jsonStr := "{\"Name\":\"铁牛\", \"Age\":18,\"Birthday\":\"2020-02-02\",\"Sal\":1}"
	// 定义一个Monster实例
	var monster Monster
	err := json.Unmarshal([]byte(jsonStr), &monster)
	if err != nil{
		fmt.Printf("unarshar err=%v", err)
	}
	fmt.Printf("反序列化后 monster=%v\n", monster)
}

func main() {
	// 定义一个反序列化
	unmarshalStruct()
}

使用json.Unmarshal()将 json 数据格式反序列化

二、map操作：

1.map序列化：

package main

import (
	"encoding/json"
	"fmt"
)

// 将map进行序列化
func testMap(){
	// 定义一个Map, key 是String 类型 值是interface类型
	var myMap map[string]interface{}
	// 使用map之前, 需要make 类型
	myMap = make(map[string]interface{})
	myMap["name"] = "铁牛"
	myMap["age"] = 18
	myMap["sal"] = 10.00
	// 将myMap进行序列化
	data, err := json.Marshal(myMap)  // 因为map就是引用类型, 所以前面不需要加&
	if err != nil{
		fmt.Printf("map序列化的错误  err=%v", err)
	}
	fmt.Printf("map 序列化后=%v", string(data))
}

func main () {
	// map 进行序列化
	testMap()
}

2.map反序列化：

package main

import (
	"encoding/json"
	"fmt"
)

// 将字符串反序列化成Map
func unmarshalMap() {
	jsonStr := "{\"age\":18, \"name\": \"铁牛\", \"sal\":10}"
	// 定义一个map
	var myMap map[string]interface{}

	// 反序列话, 不需要进行make 操作
	err := json.Unmarshal([]byte(jsonStr), &myMap)
	if err != nil{
		fmt.Printf("unmarshl err=%v", err)
	}
	fmt.Printf("反序列化 map:%v", myMap)
}

func main () {
	unmarshalMap()
}

注意：反序列化map，不需要make，因为make操作被封装到 Unmarshal函数

三、切片(slice):

1.切片序列化：

package main

import (
	"encoding/json"
	"fmt"
)

// 演示对切片进行序列化
func testSlice () {
	var mySlice []map[string]interface{}
	var m1 map[string]interface{}
	//使用map 前需要进行make
	m1 = make(map[string]interface{})
	m1["name"] = "jack"
	m1["age"] = 15
	mySlice = append(mySlice, m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "tom"
	m2["age"] = 18
	mySlice = append(mySlice, m2)

	data, err := json.Marshal(mySlice)  // slice 也是引用类型 不需要特意加&
	if err != nil{
		fmt.Printf("序列化错误 err=%v", err)
	}
	fmt.Printf("slice 序列化:%v", string(data))
}

func main (){
	// 运行切片序列化
	testSlice()
}

2.切片反序列化：

package main

import (
	"encoding/json"
	"fmt"
)

// 将json字符串, 反序列化成切片
func unmarshalSlice () {
	jsonStr := "[{\"age\":15, \"name\": \"jack\"},{\"age\": 18, \"name\": \"tom\"}]"
	// 定义一个slice
	var mySlice []map[string]interface{}
	// 反序列化slice, 也不需要操作make
	err := json.Unmarshal([]byte(jsonStr), &mySlice)
	if err != nil{
		fmt.Printf("错误信息 err=%v", err)
	}
	fmt.Printf("切片反序列化后:%v", mySlice)
}

func main() {
	unmarshalSlice()
}

同样slice反序列化也不需要make操作，Unmarshal()做了处理

四、总结：

1. 在反序列化一个json字符串时，确保反序列化后的数据类型和原来序列化类型一致。

2. 序列化使用：

   data, err := json.Marshal(引用类型)
   if err != nil{
       fmt.Printf("错误  err=%v", err)
   }
   fmt.Printf("序列化后=%v", string(data))  // 返回的是byte[] 需要转换string
   

3. 反序列化使用：

   err := json.Unmarshal([]byte(jsonStr), 引用类型)
   if err != nil{
       fmt.Printf("错误信息 err=%v", err)
   }
   fmt.Printf("反序列化后:%v", mySlice)
   // 反序列化不需要make操作, 需要将string类型转换成[]byte类型