Go语言Datastore存储：Interface{}类型参数的正确使用姿势

func save(kind string, c appengine.Context, object interface{}) {
    k := datastore.NewKey(c, kind, "some_key", 0, nil)
    // 错误示例：试图获取interface{}变量的地址
    _, err := datastore.Put(c, k, &object) 
    // ... 错误处理
}
// 调用时：save("MyType", c, someMyTypeObject)

package main

import (
    "fmt"
    "reflect" // 引入reflect包用于演示
    "github.com/stretchr/testify/mock" // 假设的mock库，用于模拟appengine.Context和datastore
)

// 模拟appengine.Context接口
type MockContext struct {
    mock.Mock
}

func (m *MockContext) Call(service, method string, in, out interface{}) error {
    args := m.Called(service, method, in, out)
    return args.Error(0)
}

// 模拟datastore.Key
type Key struct {
    Kind string
    ID   string
}

func NewKey(c *MockContext, kind, id string, _ int64, _ *Key) *Key {
    return &Key{Kind: kind, ID: id}
}

// 模拟datastore.Put函数
// 实际上datastore.Put的签名是 func Put(c appengine.Context, k *Key, src interface{}) (*Key, error)
// 这里简化以演示类型检查
func MockDatastorePut(c *MockContext, k *Key, src interface{}) (*Key, error) {
    // 在真实的datastore.Put中，这里会进行反射检查src是否为结构体指针
    // 我们在这里模拟这个检查
    if reflect.TypeOf(src).Kind() != reflect.Ptr || reflect.TypeOf(src).Elem().Kind() != reflect.Struct {
        return nil, fmt.Errorf("datastore: invalid entity type: expected a struct pointer, got %T", src)
    }
    fmt.Printf("模拟Datastore Put成功：Kind=%s, ID=%s, Data=%v\n", k.Kind, k.ID, src)
    return k, nil
}

// 定义一个示例结构体
type MyType struct {
    Name  string
    Value int
}

// 修正后的save函数
func save(kind string, c *MockContext, object interface{}) error {
    k := NewKey(c, kind, "some_key", 0, nil)
    // 直接将object传递给MockDatastorePut，因为object现在已经持有了指针
    _, err := MockDatastorePut(c, k, object) 
    if err != nil {
        fmt.Printf("保存失败: %v\n", err)
        return err
    }
    fmt.Println("数据保存成功！")
    return nil
}

func main() {
    // 模拟Context
    mockC := new(MockContext)
    // 这里不需要对mockC进行特殊的mocking，因为我们模拟了NewKey和MockDatastorePut

    // 创建一个MyType实例
    someMyTypeObject := MyType{Name: "Test", Value: 123}

    // 正确的调用方式：传入someMyTypeObject的地址
    fmt.Println("--- 尝试正确调用 ---")
    err := save("MyType", mockC, &someMyTypeObject) // 注意这里的&someMyTypeObject
    if err != nil {
        fmt.Println("正确调用失败，但理论上不应失败:", err)
    }

    // 错误调用示例（为了演示问题）
    fmt.Println("\n--- 尝试错误调用 (传入值而非指针) ---")
    err = save("MyType", mockC, someMyTypeObject) // 传入值，object内部是MyType而不是*MyType
    if err != nil {
        fmt.Println("错误调用如预期失败:", err)
    }

    // 原始问题中的错误调用方式（为了演示问题）
    // 注意：在实际Go代码中，&object 这种操作在外部泛型函数中是无效的，
    // 因为MockDatastorePut(c, k, &object) 会导致 MockDatastorePut 收到 *interface{}
    // 我们在MockDatastorePut中已经模拟了这种检查
    fmt.Println("\n--- 尝试原始问题中的错误调用 (传递&object) ---")
    func(kind string, c *MockContext, object interface{}) {
        k := NewKey(c, kind, "some_key", 0, nil)
        // 这里的object是MyType值，&object是*interface{}
        _, err := MockDatastorePut(c, k, &object) 
        if err != nil {
            fmt.Printf("原始错误调用如预期失败: %v\n", err)
        }
    }("MyType", mockC, someMyTypeObject)
}