Go 泛型数据存储与反序列化：深入理解 Gob 编码

package main

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

// store 函数用于将任意Go数据类型编码并存储到文件中
func store(filename string, data interface{}) error {
    // 1. 创建一个 bytes.Buffer 作为 gob 编码的写入目标
    // bytes.Buffer 实现了 io.Writer 接口
    buffer := new(bytes.Buffer)

    // 2. 创建一个新的 gob 编码器
    encoder := gob.NewEncoder(buffer)

    // 3. 将数据编码到 buffer 中
    err := encoder.Encode(data)
    if err != nil {
        return fmt.Errorf("gob 编码失败: %w", err)
    }

    // 4. 将 buffer 中的字节写入文件
    // 0600 表示文件权限：所有者可读写，其他用户无权限
    err = ioutil.WriteFile(filename, buffer.Bytes(), 0600)
    if err != nil {
        return fmt.Errorf("写入文件失败: %w", err)
    }
    return nil
}

// load 函数用于从文件中读取 gob 编码的数据并解码到指定的Go数据类型
// 参数 'e' 必须是一个指向目标数据类型的指针
func load(filename string, e interface{}) error {
    // 1. 从文件中读取所有字节
    encodedData, err := ioutil.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("读取文件失败: %w", err)
    }

    // 2. 创建一个 bytes.Buffer，将读取到的字节作为其内容
    // bytes.Buffer 实现了 io.Reader 接口
    buffer := bytes.NewBuffer(encodedData)

    // 3. 创建一个新的 gob 解码器
    decoder := gob.NewDecoder(buffer)

    // 4. 将 buffer 中的数据解码到 'e' 指向的变量中
    // 注意：e 必须是一个指针，gob 解码器会将数据填充到该指针指向的内存地址
    err = decoder.Decode(e)
    if err != nil {
        return fmt.Errorf("gob 解码失败: %w", err)
    }
    return nil
}

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "io/ioutil"
    "os" // 推荐使用 os 包进行文件操作
)

// store 函数用于将任意Go数据类型编码并存储到文件中
func store(filename string, data interface{}) error {
    buffer := new(bytes.Buffer)
    encoder := gob.NewEncoder(buffer)

    err := encoder.Encode(data)
    if err != nil {
        return fmt.Errorf("gob 编码失败: %w", err)
    }

    // 推荐使用 os.WriteFile
    err = os.WriteFile(filename, buffer.Bytes(), 0600)
    if err != nil {
        return fmt.Errorf("写入文件失败: %w", err)
    }
    return nil
}

// load 函数用于从文件中读取 gob 编码的数据并解码到指定的Go数据类型
// 参数 'e' 必须是一个指向目标数据类型的指针
func load(filename string, e interface{}) error {
    // 推荐使用 os.ReadFile
    encodedData, err := os.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("读取文件失败: %w", err)
    }

    buffer := bytes.NewBuffer(encodedData)
    decoder := gob.NewDecoder(buffer)

    err = decoder.Decode(e)
    if err != nil {
        return fmt.Errorf("gob 解码失败: %w", err)
    }
    return nil
}

func main() {
    filename := "dep_data.gob"

    // 1. 准备要存储的原始数据
    originalMap := map[string]string{
        "name":    "Go Programming",
        "version": "1.19",
        "author":  "Gopher",
    }
    fmt.Printf("原始数据: %v\n", originalMap)

    // 2. 存储数据
    err := store(filename, originalMap)
    if err != nil {
        fmt.Printf("存储数据失败: %v\n", err)
        return
    }
    fmt.Printf("数据已成功存储到 %s\n", filename)

    // 3. 声明一个变量来接收解码后的数据
    // 注意：必须是与原始数据类型相同的变量，且需要传入其指针
    var loadedMap map[string]string
    err = load(filename, &loadedMap) // 传入 loadedMap 的地址
    if err != nil {
        fmt.Printf("加载数据失败: %v\n", err)
        return
    }
    fmt.Printf("加载后的数据: %v\n", loadedMap)
    fmt.Printf("加载后的数据 'name' 字段: %s\n", loadedMap["name"])

    // 尝试存储和加载一个结构体
    type User struct {
        ID   int
        Name string
        Age  int
    }
    originalUser := User{ID: 1, Name: "Alice", Age: 30}
    fmt.Printf("\n原始用户数据: %v\n", originalUser)

    err = store("user_data.gob", originalUser)
    if err != nil {
        fmt.Printf("存储用户数据失败: %v\n", err)
        return
    }
    fmt.Printf("用户数据已成功存储到 user_data.gob\n")

    var loadedUser User
    err = load("user_data.gob", &loadedUser)
    if err != nil {
        fmt.Printf("加载用户数据失败: %v\n", err)
        return
    }
    fmt.Printf("加载后的用户数据: %v\n", loadedUser)
    fmt.Printf("加载后的用户数据 'Name' 字段: %s\n", loadedUser.Name)

    // 清理生成的文件 (可选)
    os.Remove(filename)
    os.Remove("user_data.gob")
}