Go gob 实现通用数据结构序列化与反序列化教程

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "io/ioutil" // 在Go 1.16+中，推荐使用os.WriteFile
)

// store 函数将任意Go数据结构编码并存储到文件中
func store(data interface{}) {
    // 初始化一个 bytes.Buffer 作为 gob 编码的写入目标
    // bytes.Buffer 实现了 io.Writer 接口
    m := new(bytes.Buffer)
    enc := gob.NewEncoder(m)

    // 编码数据。data 可以是任何Go类型
    err := enc.Encode(data)
    if err != nil {
        panic(fmt.Errorf("gob encode failed: %w", err))
    }

    // 将编码后的字节数据写入文件
    // 注意：文件权限 0600 表示只有文件所有者有读写权限
    err = ioutil.WriteFile("dep_data", m.Bytes(), 0600)
    if err != nil {
        panic(fmt.Errorf("write file failed: %w", err))
    }
    fmt.Printf("Data successfully stored.\n")
}

// load 函数从文件中读取编码数据，并将其解码到提供的目标变量中
// 注意：e 必须是一个指向期望类型的指针
func load(e interface{}) {
    // 从文件中读取所有字节
    n, err := ioutil.ReadFile("dep_data")
    if err != nil {
        panic(fmt.Errorf("read file failed: %w", err))
    }

    // 将读取的字节数据放入 bytes.Buffer，作为 gob 解码的读取源
    // bytes.Buffer 实现了 io.Reader 接口
    p := bytes.NewBuffer(n)
    dec := gob.NewDecoder(p)

    // 解码数据到 e。e 必须是一个指针，指向将要填充数据的目标变量
    err = dec.Decode(e)
    if err != nil {
        panic(fmt.Errorf("gob decode failed: %w", err))
    }
    fmt.Printf("Data successfully loaded.\n")
}

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "io/ioutil" // 在Go 1.16+中，推荐使用os.WriteFile
)

// store 函数将任意Go数据结构编码并存储到文件中
func store(data interface{}) {
    m := new(bytes.Buffer)
    enc := gob.NewEncoder(m)

    err := enc.Encode(data)
    if err != nil {
        panic(fmt.Errorf("gob encode failed: %w", err))
    }

    err = ioutil.WriteFile("dep_data", m.Bytes(), 0600)
    if err != nil {
        panic(fmt.Errorf("write file failed: %w", err))
    }
    fmt.Printf("Data successfully stored.\n")
}

// load 函数从文件中读取编码数据，并将其解码到提供的目标变量中
// 注意：e 必须是一个指向期望类型的指针
func load(e interface{}) {
    n, err := ioutil.ReadFile("dep_data")
    if err != nil {
        panic(fmt.Errorf("read file failed: %w", err))
    }

    p := bytes.NewBuffer(n)
    dec := gob.NewDecoder(p)

    err = dec.Decode(e)
    if err != nil {
        panic(fmt.Errorf("gob decode failed: %w", err))
    }
    fmt.Printf("Data successfully loaded.\n")
}

func main() {
    // 示例1: 存储和加载一个 map[string]string
    originalMap := map[string]string{"name": "Alice", "city": "New York"}
    fmt.Println("Original Map:", originalMap)

    // 存储数据
    store(originalMap)

    // 声明一个变量来接收解码后的数据，并确保它是期望的类型
    var loadedMap map[string]string
    // 加载数据，注意这里传递的是 loadedMap 的地址
    load(&loadedMap)

    fmt.Println("Loaded Map:", loadedMap)
    fmt.Println("Value of 'name' in loaded map:", loadedMap["name"]) // 输出: Alice

    fmt.Println("\n-----------------------------------\n")

    // 示例2: 存储和加载一个自定义结构体
    type Person struct {
        Name string
        Age  int
    }
    originalPerson := Person{Name: "Bob", Age: 30}
    fmt.Println("Original Person:", originalPerson)

    // 存储结构体数据
    store(originalPerson)

    // 声明一个变量来接收解码后的结构体
    var loadedPerson Person
    // 加载结构体数据
    load(&loadedPerson)

    fmt.Println("Loaded Person:", loadedPerson)
    fmt.Println("Name of loaded person:", loadedPerson.Name) // 输出: Bob
}