go wire 使用的疑问

Question

需求

database，假设有两个实现，redis跟MySQL
userService用Redis的实现，
groupService用MySQL的实现。

问题：
不管我怎么配置，始终无法实现这个需求

database

import "fmt"

type Database interface {
    GetById(id string) map[string]interface{}
}

// ===== 模拟redis =====
var _ Database = (*RedisData)(nil)

type RedisData struct {
}

func NewRedisData() Database {
    fmt.Println("===== NewRedisData =====")
    return &RedisData{}
}

func (r *RedisData) GetById(id string) map[string]interface{} {
    fmt.Println("redis GetById " + id)
    return map[string]interface{}{
        "id":   id,
        "name": "redis",
    }
}

// ===== 模拟MySQL =====
var _ Database = (*MySqlData)(nil)

type MySqlData struct {
}

func NewMySqlData() Database {
    fmt.Println("===== NewMySqlData =====")
    return &MySqlData{}
}

func (r *MySqlData) GetById(id string) map[string]interface{} {
    fmt.Println("mysql GetById " + id)
    return map[string]interface{}{
        "id":   id,
        "name": "mysql",
    }
}

userService

type User struct {
    Id   string `json:"id"`
    Name string `json:"name"`
}

type UserService interface {
    GetUser(id string) *User
}

var _ UserService = (*userService)(nil)

type userService struct {
    db Database
}

func NewUserService(db Database) UserService {
    return &userService{db: db}
}

func (u *userService) GetUser(id string) *User {
    data := u.db.GetById(id)
    return toUser(data)
}

func toUser(data map[string]interface{}) *User {
    u := &User{
        Id:   data["id"].(string),
        Name: data["name"].(string),
    }

    return u
}

groupService

type Group struct {
    Id   string `json:"id"`
    Name string `json:"name"`
}

type GroupService interface {
    GetGroup(id string) *Group
}

var _ GroupService = (*groupService)(nil)

type groupService struct {
    db Database
}

func NewGroupService(db Database) GroupService {
    return &groupService{db: db}
}

func (u *groupService) GetGroup(id string) *Group {
    data := u.db.GetById(id)
    return toGroup(data)
}

func toGroup(data map[string]interface{}) *Group {
    u := &Group{
        Id:   data["id"].(string),
        Name: data["name"].(string),
    }

    return u
}

app

import "fmt"

type App struct {
    db           Database
    userService  UserService
    groupService GroupService
}

func NewApp(
    db Database,
    userService UserService,
    groupService GroupService,
) *App {
    return &App{
        db:           db,
        userService:  userService,
        groupService: groupService,
    }
}

func (a *App) Run() {
    fmt.Println("app run")
}

provider

import (
    "github.com/google/wire"
)

var ProviderSet = wire.NewSet(NewUserService, NewRedisData, NewGroupService, NewMySqlData, NewApp)

func InitializeApp() *App {
    wire.Build(ProviderSet)
    return nil
}

Answer 1

以下回复参考：皆我百晓生、券券喵儿等免费微信小程序作答:

我理解你的问题在于如何在初始化过程中选择使用 Redis 或 MySQL 数据库，根据服务类型的不同来选择。对于这个问题，使用 wire 库的一个限制是无法根据某些条件来动态构建对象，你需要一个方法来将服务依赖与数据库实现关联起来。一个可能的解决方案是使用工厂函数和接口的组合来实现这个需求。我们可以修改一下你的代码来支持这个功能。我将使用两个结构体 UserServiceImpl 和 GroupServiceImpl 来处理具体服务的实现，并创建一个函数来决定哪个数据库应该用于特定的服务。这里是一种可能的实现方式：

首先定义一些函数来确定用户或组的服务使用哪种数据库：

func UseRedisForUserService() UserService {
    redisData := NewRedisData()
    return NewUserService(redisData)
}

func UseMySQLForGroupService() GroupService {
    mysqlData := NewMySqlData()
    return NewGroupService(mysqlData)
}

然后在构建应用程序的时候调用这些函数来初始化服务和数据库：

func InitializeApp() *App {
    userService := UseRedisForUserService() // 这里使用 Redis 数据服务来实现用户服务
    groupService := UseMySQLForGroupService() // 这里使用 MySQL 数据服务来实现组服务
    app := NewApp(nil, userService, groupService) // 使用选择的服务来构建应用程序实例
    return app
}

注意这里我们没有直接使用 wire 来构建应用程序，因为 wire 无法处理这种动态依赖关系。但是你可以通过工厂函数和手动初始化来满足你的需求。在 NewApp 函数中，你可以接受一个数据库实例作为参数，然后在应用程序内部根据需要使用不同的服务实例。这样你就可以根据服务类型动态选择使用 Redis 还是 MySQL 数据库了。