模拟 web 项目初始化过程
package main
import "fmt"
type DB struct {
}
type Cache struct {
}
type UserRepo struct {
DB *DB
Cache *Cache
}
type UserService struct {
UserRepo *UserRepo
}
type App struct {
UserService *UserService
}
func (app *App) Start() {
fmt.Println("server starting")
}
func NewDB() (*DB, func(), error) {
db := &DB{}
cleanup := func() {
fmt.Println("close db connection")
}
return db, cleanup, nil
}
func NewCache() *Cache {
return &Cache{}
}
func NewUserRepo(db *DB, cache *Cache) *UserRepo {
return &UserRepo{DB: db, Cache: cache}
}
func NewUserService(userRepo *UserRepo) *UserService {
return &UserService{UserRepo: userRepo}
}
func NewApp(userService *UserService) *App {
return &App{UserService: userService}
}
不使用 wire
手动 new 方式初始化
func main() {
db, cleanup, err := NewDB()
if err != nil {
panic(err)
}
defer cleanup()
cache := NewCache()
userRepo := NewUserRepo(db, cache)
userService := NewUserService(userRepo)
app := NewApp(userService)
app.Start()
}
使用 DI
go install github.com/google/wire/cmd/wire@latest
创建 wire.go 用于生成代码，申明了最初始的入参和最终的产出物
//go:build wireinject
// +build wireinject
package main
import (
"github.com/google/wire"
)
// InitializeApplication
func InitializeApplication() (*App, func(), error) {
panic(wire.Build(NewDB, NewCache, NewUserRepo, NewUserService, NewApp))
}
生成对应的依赖关系和初始化过程
在使用的地方调用对应的初始化方法获得产物即可，不需要关心其中的依赖关系
func main() {
app, cleanup, err := InitializeApplication()
if err != nil {
panic(err)
}
defer cleanup()
app.Start()
}
wire 在每个 new 方法中支持三个参数，对象，cleanup，error，参数 cleanup 就会在关闭的时候按照依赖的倒序依次进行关闭。
wire 做的事情就是根据你 new 方法的入参和出参，识别了他们之间的依赖关系，生成了对应的初始化代码
