Go语言通用数据结构Gob编码与解码实践指南

package main

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

// store 函数将任意类型的数据编码并保存到文件中
func store(data interface{}, filename string) error {
    // 1. 创建一个 bytes.Buffer 作为编码的目标
    buffer := new(bytes.Buffer)
    // 2. 创建 gob.Encoder
    encoder := gob.NewEncoder(buffer)

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

    // 4. 将编码后的字节数据写入文件
    err = ioutil.WriteFile(filename, buffer.Bytes(), 0600)
    if err != nil {
        return fmt.Errorf("写入文件失败: %w", err)
    }
    log.Printf("数据已成功保存到 %s", filename)
    return nil
}

package main

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

// load 函数从文件中读取并解码数据到目标接口
// 注意：e 必须是一个指向目标类型的指针
func load(e interface{}, filename string) error {
    // 1. 从文件中读取字节数据
    dataBytes, err := ioutil.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("读取文件失败: %w", err)
    }

    // 2. 创建一个 bytes.Buffer，并用读取到的数据填充
    buffer := bytes.NewBuffer(dataBytes)
    // 3. 创建 gob.NewDecoder
    decoder := gob.NewDecoder(buffer)

    // 4. 解码数据到传入的指针 e
    // e 必须是一个指向目标类型的指针，否则解码会失败
    err = decoder.Decode(e)
    if err != nil {
        return fmt.Errorf("gob 解码失败: %w", err)
    }
    log.Printf("数据已成功从 %s 加载", filename)
    return nil
}

package main

import (
    "fmt"
    "log"
    // 确保导入了 encoding/gob 以便在需要时注册类型
    "encoding/gob" 
)

// Person 是一个自定义结构体，我们将用 gob 存储它
type Person struct {
    Name string
    Age  int
    Email string // 新增字段
}

// init 函数用于注册自定义类型，确保 gob 能够识别和处理它
// 对于直接编码具体结构体实例，通常不需要显式注册，
// 但如果结构体作为接口值被编码，或者包含接口字段，则注册是必要的。
func init() {
    gob.Register(Person{}) 
}

func main() {
    // 示例 1: 存储和加载 map[string]string
    originalMap := map[string]string{
        "name":    "Alice",
        "city":    "New York",
        "country": "USA",
    }
    log.Printf("原始 map 数据: %v", originalMap)

    mapFilename := "my_gob_map_data.dat"

    // 存储 map 数据
    err := store(originalMap, mapFilename)
    if err != nil {
        log.Fatalf("存储 map 数据失败: %v", err)
    }

    // 声明一个变量来接收解码后的 map 数据，注意这里必须是原始类型的指针
    var loadedMap map[string]string
    err = load(&loadedMap, mapFilename) // 传入 loadedMap 的地址
    if err != nil {
        log.Fatalf("加载 map 数据失败: %v", err)
    }

    log.Printf("加载后的 map 数据: %v", loadedMap)
    fmt.Printf("加载后的 'name' 字段: %s\n", loadedMap["name"]) // 预期输出: Alice

    fmt.Println("------------------------------------")

    // 示例 2: 存储和加载自定义结构体 Person
    originalPerson := Person{Name: "Bob", Age: 30, Email: "bob@example.com"}
    log.Printf("原始 Person 数据: %v", originalPerson)

    personFilename := "my_gob_person_data.dat"

    // 存储 Person 数据
    err = store(originalPerson, personFilename)
    if err != nil {
        log.Fatalf("存储 Person 数据失败: %v", err)
    }

    // 声明一个变量来接收解码后的 Person 数据
    var loadedPerson Person
    err = load(&loadedPerson, personFilename) // 传入 loadedPerson 的地址
    if err != nil {
        log.Fatalf("加载 Person 数据失败: %v", err)
    }
    log.Printf("加载后的 Person 数据: %v", loadedPerson)
    fmt.Printf("加载后的 Person Name: %s, Age: %d, Email: %s\n", 
        loadedPerson.Name, loadedPerson.Age, loadedPerson.Email) // 预期输出: Bob, 30, bob@example.com

    fmt.Println("------------------------------------")

    // 示例 3: 尝试加载一个错误类型 (例如，将 map 数据加载到 Person 结构体)
    log.Println("尝试将 map 数据加载到 Person 结构体 (预期会失败):")
    var wrongType Person
    err = load(&wrongType, mapFilename) // mapFilename 存储的是 map[string]string
    if err != nil {
        log.Printf("加载错误类型，如预期般失败: %v", err) 
    } else {
        log.Printf("错误：意外成功加载了错误类型数据: %v", wrongType)
    }
}