Go Gob 泛型数据存储与加载教程

package main

import (
    "bytes"
    "encoding/gob"
    "io/ioutil"
    "log"
)

// store 函数将任意类型的数据编码为 gob 格式并写入文件
func store(filename string, data interface{}) error {
    // 1. 创建一个 bytes.Buffer 作为 gob 编码器的写入目标
    // bytes.Buffer 实现了 io.Writer 接口
    m := new(bytes.Buffer)
    enc := gob.NewEncoder(m)

    // 2. 编码数据
    // gob.Encoder 的 Encode 方法接受 interface{} 类型参数
    err := enc.Encode(data)
    if err != nil {
        return err
    }

    // 3. 将编码后的字节写入文件
    // m.Bytes() 返回 []byte 类型，可直接用于 ioutil.WriteFile
    err = ioutil.WriteFile(filename, m.Bytes(), 0600)
    if err != nil {
        return err
    }
    return nil
}

// load 函数从文件读取 gob 编码数据并解码到指定变量
// 注意：e 必须是一个指向目标类型的指针
func load(filename string, e interface{}) error {
    // 1. 从文件读取所有字节
    n, err := ioutil.ReadFile(filename)
    if err != nil {
        return err
    }

    // 2. 创建一个 bytes.Buffer 作为 gob 解码器的读取源
    // bytes.NewBuffer 接受 []byte 类型，bytes.Buffer 实现了 io.Reader 接口
    p := bytes.NewBuffer(n)
    dec := gob.NewDecoder(p)

    // 3. 解码数据
    // dec.Decode 必须接收一个指向目标变量的指针
    err = dec.Decode(e)
    if err != nil {
        return err
    }
    return nil
}

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "io/ioutil"
    "log"
)

// store 函数将任意类型的数据编码为 gob 格式并写入文件
func store(filename string, data interface{}) error {
    m := new(bytes.Buffer)
    enc := gob.NewEncoder(m)

    err := enc.Encode(data)
    if err != nil {
        return err
    }

    err = ioutil.WriteFile(filename, m.Bytes(), 0600)
    if err != nil {
        return err
    }
    return nil
}

// load 函数从文件读取 gob 编码数据并解码到指定变量
// 注意：e 必须是一个指向目标类型的指针
func load(filename string, e interface{}) error {
    n, err := ioutil.ReadFile(filename)
    if err != nil {
        return err
    }

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

    err = dec.Decode(e)
    if err != nil {
        return err
    }
    return nil
}

func main() {
    // 定义一个要存储的原始数据
    orgData := map[string]string{
        "name":    "Alice",
        "city":    "New York",
        "country": "USA",
    }

    filename := "generic_data.gob"

    // 1. 存储数据
    fmt.Printf("Storing original data: %v\n", orgData)
    err := store(filename, orgData)
    if err != nil {
        log.Fatalf("Failed to store data: %v", err)
    }
    fmt.Println("Data stored successfully.")

    // 2. 加载数据
    // 声明一个变量来接收加载的数据，其类型必须与原始数据类型匹配
    // 并且必须传递其地址 (指针) 给 load 函数
    var loadedMap map[string]string
    err = load(filename, &loadedMap) // 注意这里传递的是 &loadedMap
    if err != nil {
        log.Fatalf("Failed to load data: %v", err)
    }

    fmt.Printf("Loaded data: %v\n", loadedMap)
    fmt.Printf("Accessing specific key 'name': %s\n", loadedMap["name"])

    // 尝试存储和加载一个不同的类型
    type User struct {
        ID   int
        Name string
        Age  int
    }

    user := User{ID: 1, Name: "Bob", Age: 30}
    userFilename := "user_data.gob"

    fmt.Printf("\nStoring user data: %v\n", user)
    err = store(userFilename, user)
    if err != nil {
        log.Fatalf("Failed to store user data: %v", err)
    }
    fmt.Println("User data stored successfully.")

    var loadedUser User
    err = load(userFilename, &loadedUser)
    if err != nil {
        log.Fatalf("Failed to load user data: %v", err)
    }
    fmt.Printf("Loaded user data: %v\n", loadedUser)
    fmt.Printf("Loaded user name: %s\n", loadedUser.Name)
}