介紹Golang序列化和反序列化

為什麼要序列化和反序列化

　　我們的資料物件要在網路中傳輸或儲存到檔案，就需要對其編碼和解碼動作，目前存在很多編碼格式：json, XML, Gob, Google Protocol Buffer 等， Go 語言當然也支援所有這些編碼格式。

序列化與反序列化定義

　　序列化 (Serialization)是將物件的狀態資訊轉換為可以儲存或傳輸的形式的過程。在序列化期間，物件將其當前狀態寫入到臨時或永續性儲存區。通過從儲存區中讀取物件的狀態，重新建立該物件，則為反序列化

序列化和反序列化規則

Go型別 json 型別

bool booleans

float64 numbers

string strings

nil null

在解析 json 格式資料時，若以 interface{} 接收資料，需要按照以上規則進行解析。

程式碼演示

反序列化

package main

import (   "encoding/json"
   "fmt")

type People struct {
   name   string  `json:"name"` // name,小寫不匯出
   Age    int     `json:"age"`  // age
   Gender string `json:"gender"`  // gender   Lesson
}

type Lesson struct {
   Lessons []string `json:"lessons"`
}

func main() {
   jsonstr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}`   // 反序列化   var people People   if err := json.Unmarshal([]byte(jsonstr),&people); err == nil {      fmt.Println("struct people:")      fmt.Println(people)
   }   // 反序列化 json 字串中的一部分   var lessons Lesson   if err := json.Unmarshal([]byte(jsonstr),&lessons); err == nil {      fmt.Println("struct lesson:")      fmt.Println(lessons)
   }   // 反序列化 json 字串陣列
   jsonstr = `["English","History"]`
   var str []string
   if err := json.Unmarshal([]byte(jsonstr), &str); err == nil {      fmt.Println("struct str：")      fmt.Println(str)
   }
}// 列印結果　　struct people:
　　{ 18 男 {[English History]}}
　　struct lesson:
　　{[English History]}
　　struct str：
　　[English History]

反序列化

序列化

package main

import (    "encoding/json"
    "fmt")

type People struct {
    name   string  `json:"name"` // name,小寫不匯出
    Age    int     `json:"age"`  // age，在 json 字串中叫 age
    Gender string `json:"gender"`  // gender    Lesson
}

type Lesson struct {
    Lessons []string `json:"lessons"`
}

func main() {
    lesson := Lesson{[]string{"Math","English","Chinese"}}
    people := &People{
        name:   "amy",
        Age:    22,
        Gender: "female",
        Lesson: lesson,
    }    if b, err := json.Marshal(people); err != nil {        fmt.Println("Marshal failed...")
    }else {        fmt.Println(b)        fmt.Println(string(b))
    }
}    // 列印結果
    [123 34 97 103 101 34 58 50 50 44 34 103 101 110 100 101 114 34 58 34 102 101 109 97 108 101 34 44 34 108 101 115 115 111 110 115 34 58 91 34 77 97 116 104 34 44 34 69 110 103 108 105 115 104 34 44 34 67 104 105 110 101 115 101 34 93 125]
{"age":22,"gender":"female","lessons["Math","English","Chinese「}

序列化

序列化-->傳輸-->反序列化

package main

import (    "fmt"
    "encoding/json")

type Student struct {
    Name    string
    Age        int
    Guake    bool
    Classes    []string
    Price    float32
}

func (s * Student)ShowStu() {    fmt.Println("show Student :")    fmt.Println("\tName\t:", s.Name)    fmt.Println("\tAge\t:", s.Age)    fmt.Println("\tGuake\t:", s.Guake)    fmt.Println("\tPrice\t:", s.Price)    fmt.Printf("\tClasses\t: ")    for _, a := range s.Classes {        fmt.Printf("%s ", a)
    }    fmt.Println("")
}

func main() {
    st := &Student {        "Xiao Ming",        16,        true,
        []string{"Math", "English", "Chinese"},        9.99,
    }    fmt.Println("before JSON encoding :")
    st.ShowStu()

    b, err := json.Marshal(st)    if err != nil {        fmt.Println("encoding faild")
    } else {        fmt.Println("encoded data : ")        fmt.Println(b)        fmt.Println(string(b))
    }
    ch := make(chan string, 1)
    go func(c chan string, str string){
        c <- str
    }(ch, string(b))
    strData := <-ch    fmt.Println("--------------------------------")
    stb := &Student{}
    stb.ShowStu()
    err = json.Unmarshal([]byte(strData), &stb)    if err != nil {        fmt.Println("Unmarshal faild")
    } else {        fmt.Println("Unmarshal success")
        stb.ShowStu()
    }
}

範例

json 資料編碼和解碼

　　json 包提供了 Decoder 和 Encoder 型別來支援常用 json 資料流讀寫。NewDecoder 和 NewEncoder 函數分別封裝了 io.Reader 和 io.Writer 介面。

package main

import (    "encoding/json"
    "fmt"
    "os"
    "strings")

type People struct {
    name   string  `json:"name"` // name,小寫不匯出
    Age    int     `json:"age"`  // age，在 json 字串中叫 age
    Gender string `json:"gender"`  // gender    Lesson
}

type Lesson struct {
    Lessons []string `json:"lessons"`
}

func main() {

    jsonStr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}`
    strR := strings.NewReader(jsonStr)
    people := &People{}    // 用 NewDecoder && Decode 進行解碼給定義好的結構體物件 people
    err := json.NewDecoder(strR).Decode(people)    if err != nil {        fmt.Println(err)
    }    fmt.Printf("%+v",people)   //

    // 用 NewEncoder && Encode 把儲存的 people 結構體物件編碼為 json 儲存到檔案
    f, err := os.Create("./people.json")
    json.NewEncoder(f).Encode(people)

}

範例

package main

import (
    "encoding/json"
    "fmt"
    "os"
    "strings"
)

type People struct {
    name   string  `json:"name"` // name,小寫不匯出
    Age    int     `json:"age"`  // age，在 json 字串中叫 age
    Gender string `json:"gender"`  // gender
    Lesson
}

type Lesson struct {
    Lessons []string `json:"lessons"`
}

func main() {

    jsonStr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}`
    strR := strings.NewReader(jsonStr)
    people := &People{}

    // 用 NewDecoder && Decode 進行解碼給定義好的結構體物件 people
    err := json.NewDecoder(strR).Decode(people)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%+v",people)   //

    // 用 NewEncoder && Encode 把儲存的 people 結構體物件編碼為 json 儲存到檔案
    f, err := os.Create("./people.json")
    json.NewEncoder(f).Encode(people)

}

範例

以上就是介紹Golang序列化和反序列化的詳細內容，更多請關注TW511.COM其它相關文章！