Go语言中结构体到字节切片的转换：以memcache存储为例

package main

import (
    "context"
    "fmt"
    "log"

    // 假设你正在使用Google App Engine，否则你需要一个兼容的memcache客户端
    // 这里为了示例，我们假设有一个memcache包，其API与appengine/memcache类似
    // 实际项目中，你可能需要引入 "google.golang.org/appengine/v2/memcache" 或其他第三方库
    "github.com/bradfitz/gomemcache/memcache" // 这是一个常用的memcache客户端，API略有不同但概念相同
)

// 模拟appengine/memcache的Codec接口和Gob实现
// 在实际App Engine环境中，你直接使用 appengine/memcache.Gob
type Item struct {
    Key    string
    Value  []byte
    Object interface{} // 用于Codec编码/解码的字段
}

type Codec interface {
    Set(ctx context.Context, item *Item) error
    Get(ctx context.Context, key string, dst interface{}) error
}

type gobCodec struct{}

func (g *gobCodec) Set(ctx context.Context, item *Item) error {
    // 模拟gob编码过程
    // 在实际appengine/memcache.Gob中，Object会被编码到Value
    // 这里简化为如果Object不为空，则模拟成功
    if item.Object != nil {
        fmt.Printf("Gob encoding object %+v for key %s\n", item.Object, item.Key)
        item.Value = []byte("gob_encoded_data_for_" + item.Key) // 模拟编码后的字节
        return nil
    }
    return fmt.Errorf("no object to encode")
}

func (g *gobCodec) Get(ctx context.Context, key string, dst interface{}) error {
    // 模拟gob解码过程
    // 在实际appengine/memcache.Gob中，会从Value解码到dst
    // 这里简化为如果dst不为空，则模拟成功
    if dst != nil {
        fmt.Printf("Gob decoding data for key %s into %+v\n", key, dst)
        // 实际中会根据key从缓存中获取item.Value，然后解码到dst
        // 为了示例，我们假设解码成功并填充dst
        if link, ok := dst.(*Link); ok {
            link.Files = []string{"decoded_file1.txt", "decoded_file2.txt"}
        }
        return nil
    }
    return fmt.Errorf("destination object is nil")
}

var Gob Codec = &gobCodec{} // 模拟 memcache.Gob

// 示例结构体
type Link struct {
    Files []string
}

func main() {
    ctx := context.Background() // 模拟上下文

    // 1. 创建要存储的结构体实例
    myLinkVar := Link{
        Files: []string{"document.pdf", "image.jpg", "report.xlsx"},
    }

    // 2. 创建memcache.Item，并将结构体赋值给Object字段
    // 注意：Key是缓存的键，Object是我们要编码的Go对象
    item := &Item{
        Key:    "myCacheKey",
        Object: &myLinkVar, // 注意这里传递的是结构体的指针
    }

    // 3. 使用memcache.Gob.Set()方法进行存储
    // Gob编码器会自动将item.Object编码成[]byte并存储
    err := Gob.Set(ctx, item) // 在实际App Engine中是 memcache.Gob.Set(ctx, item)
    if err != nil {
        log.Fatalf("Failed to set item using Gob: %v", err)
    }
    fmt.Println("Struct successfully stored in memcache using Gob.")

    // --- 数据检索与解码 ---
    fmt.Println("\nRetrieving data from memcache...")

    // 1. 创建一个空结构体变量，用于接收解码后的数据
    retrievedLink := Link{}

    // 2. 使用memcache.Gob.Get()方法检索和解码
    // Get方法需要提供缓存键和用于接收数据的目标结构体指针
    err = Gob.Get(ctx, "myCacheKey", &retrievedLink) // 在实际App Engine中是 memcache.Gob.Get(ctx, "myCacheKey", &retrievedLink)
    if err != nil {
        log.Fatalf("Failed to get item using Gob: %v", err)
    }
    fmt.Printf("Retrieved Link: %+v\n", retrievedLink)
}

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Password string `json:"-"` // 忽略此字段不进行JSON编码
}

// 存储
item := &Item{
    Key:    "user_data",
    Object: &myUserVar,
}
err := JSON.Set(ctx, item) // 假设存在 memcache.JSON

// 检索
retrievedUser := User{}
err = JSON.Get(ctx, "user_data", &retrievedUser) // 假设存在 memcache.JSON