• 技术文章 >后端开发 >Golang

    介绍Golang序列化和反序列化

    藏色散人藏色散人2020-09-30 13:48:56转载129
    下面由golang教程栏目给大家介绍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序列化和反序列化的详细内容,更多请关注php中文网其它相关文章!

    本文转载于:cnblogs,如有侵犯,请联系a@php.cn删除
    专题推荐:Golang
    上一篇:关于Golang切片的三种简单使用方式及区别 下一篇:关于golang的make
    第14期线上培训班

    相关文章推荐

    • 教你使用Golang和lua实现一个值班机器人• 你知道golang中Context的使用场景有哪些吗• 关于Golang panic用法详解• 关于Golang切片的三种简单使用方式及区别

    全部评论我要评论

  • 取消发布评论发送
  • 1/1

    PHP中文网