Go 接口实现深度解析：方法签名匹配的严格要求

package mymodels

// 定义一个映射类型，方便使用
type M map[string]interface{}

// collectionSlice 接口，用于Find操作的结果集
type collectionSlice interface {
    One(interface{}) error
}

// collection 接口，定义了Upsert和Find操作
type collection interface {
    Upsert(interface{}, interface{}) (interface{}, error)
    Find(interface{}) collectionSlice // 注意这里的返回类型是自定义接口
}

// database 接口，定义了获取collection的方法
type database interface {
    C(string) collection // 注意这里的返回类型是自定义接口
}

// FindItem 是一个使用database接口的函数
func FindItem(defindex int, d database) (*Item, error) {
    // 实际业务逻辑...
    return nil, nil
}

package controllers

import (
    "context" // 假设ctx包含mgo.Database
    "mymodels" // 引入我们定义的接口
    "gopkg.in/mgo.v2" // 引入mgo库
)

type Context struct {
    Database *mgo.Database
    // ... 其他字段
}

func SomeHandler(ctx *Context, defindex int) {
    // 尝试将 *mgo.Database 传递给 FindItem
    // item, err := mymodels.FindItem(defindex, ctx.Database) // 这里会报错！
    // ...
}

cannot use ctx.Database (type *mgo.Database) as type mymodels.database in function argument:
*mgo.Database does not implement mymodels.database (wrong type for C method)
have C(string) *mgo.Collection
want C(string) mymodels.collection

package mymodels

import (
    "gopkg.in/mgo.v2" // 引入mgo库
)

// 定义一个映射类型，方便使用
type M map[string]interface{}

// collectionSlice 接口
type collectionSlice interface {
    One(interface{}) error
}

// collection 接口
type collection interface {
    Upsert(interface{}, interface{}) (interface{}, error)
    Find(interface{}) collectionSlice
}

// database 接口
type database interface {
    C(string) collection
}

// --- 以下是包装器实现 ---

// mgoCollectionWrapper 包装 *mgo.Collection，使其实现 collectionSlice 和 collection 接口
type mgoCollectionWrapper struct {
    coll *mgo.Collection
}

func (mcw *mgoCollectionWrapper) One(result interface{}) error {
    return mcw.coll.Find(nil).One(result) // 假设 Find(nil) 就能获取到 One 方法
}

func (mcw *mgoCollectionWrapper) Upsert(selector, update interface{}) (info interface{}, err error) {
    return mcw.coll.Upsert(selector, update)
}

func (mcw *mgoCollectionWrapper) Find(query interface{}) collectionSlice {
    // mgo.Collection.Find 返回的是 *mgo.Query，我们需要将其包装成 collectionSlice
    return &mgoQueryWrapper{query: mcw.coll.Find(query)}
}

// mgoQueryWrapper 包装 *mgo.Query，使其实现 collectionSlice 接口
type mgoQueryWrapper struct {
    query *mgo.Query
}

func (mqw *mgoQueryWrapper) One(result interface{}) error {
    return mqw.query.One(result)
}

// mgoDatabaseWrapper 包装 *mgo.Database，使其实现 database 接口
type mgoDatabaseWrapper struct {
    db *mgo.Database
}

func (mdw *mgoDatabaseWrapper) C(name string) collection {
    // 返回一个包装后的 collection
    return &mgoCollectionWrapper{coll: mdw.db.C(name)}
}

// NewMgoDatabaseWrapper 提供一个构造函数
func NewMgoDatabaseWrapper(db *mgo.Database) database {
    return &mgoDatabaseWrapper{db: db}
}

// FindItem 是一个使用database接口的函数
func FindItem(defindex int, d database) (*Item, error) {
    // 假设 Item 是一个结构体
    type Item struct {
        Defindex int `bson:"defindex"`
        Name string `bson:"name"`
    }

    coll := d.C("items") // 获取collection
    item := &Item{}
    err := coll.Find(M{"defindex": defindex}).One(item)
    if err != nil {
        return nil, err
    }
    return item, nil
}

package controllers

import (
    "context" // 假设ctx包含mgo.Database
    "mymodels" // 引入我们定义的接口和包装器
    "gopkg.in/mgo.v2" // 引入mgo库
    "log"
)

type Context struct {
    Database *mgo.Database
    // ... 其他字段
}

func SomeHandler(ctx *Context, defindex int) {
    // 使用包装器将 *mgo.Database 转换为 mymodels.database 接口类型
    dbInterface := mymodels.NewMgoDatabaseWrapper(ctx.Database)

    item, err := mymodels.FindItem(defindex, dbInterface)
    if err != nil {
        log.Printf("Error finding item: %v", err)
        return
    }
    log.Printf("Found item: %+v", item)
}