数据库仓储设计：单一Store接口VS按表拆分接口的实践与实现疑问

1. 按表拆分仓储接口是否属于最佳实践？ #

是的，这种拆分方式完全符合单一职责原则，是Go后端开发中的常见最佳实践，你的团队提到的优势确实成立：

• 职责更清晰：每个仓储接口只对应单一业务实体（用户/房屋），接口定义聚焦，后续维护时能快速定位对应模块，避免大接口逐渐臃肿。
• 降低测试Mock成本：测试仅依赖用户操作的服务时，只需Mock UserStore 接口的方法，不用为大Store接口中无关的房屋操作编写空实现，测试代码更简洁。
• 按需依赖解耦：业务服务可仅注入自身需要的仓储接口（比如用户服务只依赖UserStore），避免不必要的依赖耦合，契合依赖倒置原则。

当然，极小项目或单一实体的简单场景下，统一接口也能正常工作，但在中大型项目中，拆分接口的优势会非常明显。

2. 拆分后如何通过NewMongoDBStore返回不同仓储实例？ #

推荐两种简洁的实现方案：

方案一：返回聚合多仓储接口的结构体 #

定义一个聚合结构体，将拆分后的UserStore和HouseStore作为字段，NewMongoDBStore初始化MongoDB连接后，返回该结构体实例：

// store.go
type UserStore interface {
    CreateUser(user model.User) (string, error)
    GetProfile(userId string) (model.User, error)
}

type HouseStore interface {
    CreateHouse(house model.House) (string, error)
}

// 聚合仓储实例的结构体
type MongoDBStore struct {
    UserStore
    HouseStore
}

// mongo_store.go
type mongoStore struct {
    client     *mongo.Client
    userColl   *mongo.Collection
    houseColl  *mongo.Collection
}

// 实现UserStore接口
func (s *mongoStore) CreateUser(user model.User) (string, error) {
    // 具体MongoDB操作实现
}

func (s *mongoStore) GetProfile(userId string) (model.User, error) {
    // 具体MongoDB操作实现
}

// 实现HouseStore接口
func (s *mongoStore) CreateHouse(house model.House) (string, error) {
    // 具体MongoDB操作实现
}

func NewMongoDBStore(uri string) (*MongoDBStore, error) {
    client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
    if err != nil {
        return nil, err
    }
    ms := &mongoStore{
        client:    client,
        userColl:  client.Database("dbname").Collection("users"),
        houseColl: client.Database("dbname").Collection("houses"),
    }
    // 返回聚合结构体，内部嵌入实现了两个接口的mongoStore实例
    return &MongoDBStore{
        UserStore:  ms,
        HouseStore: ms,
    }, nil
}

调用方可按需获取对应仓储接口：

store, err := NewMongoDBStore("mongodb://localhost:27017")
if err != nil {
    // 处理错误
}
// 用户服务注入UserStore
userSvc := NewUserService(store.UserStore)
// 房屋服务注入HouseStore
houseSvc := NewHouseService(store.HouseStore)

方案二：提供独立的仓储构造函数（轻量化） #

如果不想使用聚合结构体，可为每个仓储接口单独提供构造函数，共享同一个MongoDB连接：

// mongo_store.go
type mongoStore struct {
    client     *mongo.Client
    userColl   *mongo.Collection
    houseColl  *mongo.Collection
}

// 先初始化全局MongoDB客户端，避免重复建立连接
func initMongoClient(uri string) (*mongo.Client, error) {
    return mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
}

func NewMongoDBUserStore(client *mongo.Client) UserStore {
    return &mongoStore{
        client:   client,
        userColl: client.Database("dbname").Collection("users"),
    }
}

func NewMongoDBHouseStore(client *mongo.Client) HouseStore {
    return &mongoStore{
        client:    client,
        houseColl: client.Database("dbname").Collection("houses"),
    }
}

调用方先初始化客户端，再生成对应仓储实例：

client, err := initMongoClient("mongodb://localhost:27017")
if err != nil {
    // 处理错误
}
userStore := NewMongoDBUserStore(client)
houseStore := NewMongoDBHouseStore(client)

内容的提问来源于stack exchange，提问作者Alireza