Go接口的依赖解耦与实现陷阱：方法签名匹配深度解析

// 定义一个用于抽象Find方法返回结果的接口
type collectionSlice interface {
    One(interface{}) error
}

// 定义一个用于抽象MongoDB集合操作的接口
type collection interface {
    Upsert(interface{}, interface{}) (interface{}, error)
    Find(interface{}) collectionSlice // 注意这里返回的是我们的 collectionSlice 接口
}

// 定义一个用于抽象MongoDB数据库操作的接口
type database interface {
    C(string) collection // 注意这里返回的是我们的 collection 接口
}

// 业务逻辑函数，依赖于 database 接口
func FindItem(defindex int, d database) (*Item, error) {
    // ... 使用 d.C("items").Find(...).One(...) 进行操作
    return nil, nil // 占位符
}

// 假设 ctx.Database 是 *mgo.Database 类型
// item, err := FindItem(int(defindex), ctx.Database)

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

// dota/interfaces.go
package dota

// 抽象 Find 方法返回结果的接口
type collectionSlice interface {
    One(interface{}) error
}

// 抽象 MongoDB 集合操作的接口
type collection interface {
    Upsert(interface{}, interface{}) (interface{}, error)
    Find(interface{}) collectionSlice
}

// 抽象 MongoDB 数据库操作的接口
type database interface {
    C(string) collection
}

// dota/mgo_wrappers.go
package dota

import "gopkg.in/mgo.v2" // 引入 mgo 包，仅在此文件使用

// mgoCollectionSliceWrapper 包装 mgo.Query 以实现 dota.collectionSlice 接口
type mgoCollectionSliceWrapper struct {
    query *mgo.Query
}

// One 方法实现 collectionSlice 接口的 One 方法
func (w *mgoCollectionSliceWrapper) One(result interface{}) error {
    return w.query.One(result)
}

// mgoCollectionWrapper 包装 mgo.Collection 以实现 dota.collection 接口
type mgoCollectionWrapper struct {
    coll *mgo.Collection
}

// Upsert 方法实现 collection 接口的 Upsert 方法
func (w *mgoCollectionWrapper) Upsert(selector, update interface{}) (interface{}, error) {
    info, err := w.coll.Upsert(selector, update)
    if err != nil {
        return nil, err
    }
    // 根据实际需求，可能需要返回 info.UpsertedId 或其他信息
    return info.UpsertedId, nil
}

// Find 方法实现 collection 接口的 Find 方法
// 注意这里返回的是我们自定义的 collectionSlice 接口，通过包装器实现
func (w *mgoCollectionWrapper) Find(query interface{}) collectionSlice {
    return &mgoCollectionSliceWrapper{query: w.coll.Find(query)}
}

// mgoDatabaseWrapper 包装 mgo.Database 以实现 dota.database 接口
type mgoDatabaseWrapper struct {
    db *mgo.Database
}

// C 方法实现 database 接口的 C 方法
// 注意这里返回的是我们自定义的 collection 接口，通过包装器实现
func (w *mgoDatabaseWrapper) C(name string) collection {
    return &mgoCollectionWrapper{coll: w.db.C(name)}
}

// NewMgoDatabaseWrapper 是一个工厂函数，用于创建 dota.database 接口的 mgo 实现实例
func NewMgoDatabaseWrapper(db *mgo.Database) database {
    return &mgoDatabaseWrapper{db: db}
}

// controllers/handlers.go
package controllers

import (
    "fmt"
    "your_module_path/dota" // 引入你的 dota 包
)

// 假设 Item 是你的数据模型
type Item struct {
    Defindex int `bson:"defindex"`
    Name     string `bson:"name"`
}

// FindItem 函数现在可以接收一个 dota.database 接口
func FindItem(defindex int, db dota.database) (*Item, error) {
    item := &Item{}
    err := db.C("items").Find(dota.M{"defindex": defindex}).One(item)
    if err != nil {
        return nil, fmt.Errorf("failed to find item: %w", err)
    }
    return item, nil
}

// main.go
package main

import (
    "fmt"
    "log"
    "gopkg.in/mgo.v2"
    "your_module_path/controllers"
    "your_module_path/dota"
)

func main() {
    // 1. 初始化 mgo 数据库连接
    session, err := mgo.Dial("mongodb://localhost:27017")
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer session.Close()

    db := session.DB("mydatabase")

    // 2. 将 mgo.Database 实例包装成 dota.database 接口
    myDotaDatabase := dota.NewMgoDatabaseWrapper(db)

    // 3. 在业务逻辑中使用包装后的接口实例
    item, err := controllers.FindItem(123, myDotaDatabase)
    if err != nil {
        log.Printf("Error finding item: %v", err)
    } else if item != nil {
        fmt.Printf("Found item: %+v\n", item)
    } else {
        fmt.Println("Item not found.")
    }

    // 示例：Upsert 操作
    newItem := &controllers.Item{Defindex: 456, Name: "New Sword"}
    upsertedID, err := myDotaDatabase.C("items").Upsert(dota.M{"defindex": 456}, newItem)
    if err != nil {
        log.Printf("Error upserting item: %v", err)
    } else {
        fmt.Printf("Upserted item with ID: %v\n", upsertedID)
    }
}