线上项目往往依赖非常多的具备特定能力的资源，如：DB、MQ、各种中间件，以及随着项目业务的复杂化，单一项目内，业务模块也逐渐增多，如何高效、整洁管理各种资源十分重要。
本文从“术”层面，讲述“依赖注入”的实现，带你体会其对于整洁架构 & DDD 等设计思想的落地，起到的支撑作用。
涉及内容：
最热门的 golang 依赖注入库，GitHub 🌟 12.5k：https://github.com/google/wire
GiuHub 🌟 22.5k 的 golang 微服务框架 kratos 默认使用 wire 作为依赖注入方式：https://github.com/go-kratos/kratos
Spring Boot 与 Golang 的依赖注入对比
依赖注入的设计哲学
📺 B站账号：白泽talk，绝大部分博客内容都将会通过视频讲解，不过文章一般是先于视频发布
白泽的开源 Golang 学习仓库：https://github.com/BaiZe1998/go-learning，用于文章归档 & 聚合博客代码案例
公众号【白泽talk】，本期内容的 pdf 版本，可以关注公众号，回复【依赖注入】获得，往期资源的获取，都是类似的方式。
📒 本文所涉及编写的代码，已收录于 https://github.com/BaiZe1998/go-learning/di 目录
一句话概括：实例 A 的创建，依赖于实例 B 的创建，且在实例 A 的生命周期内，持有对实例 B 的访问权限。
依赖注入（Dependency Injection, DI），以 Golang 为例，左侧为手动完成依赖注入，右侧为不使用依赖注入：
🌟 不使用依赖注入风险：
package main
var (
mysqlUrl = "mysql://blabla"
// 全局数据库实例
db = NewMySQLClient(mysqlUrl)
)
func NewMySQLClient(url string) *MySQLClient {
return &MySQLClient{url: url}
}
type MySQLClient struct {
url string
}
func (c *MySQLClient) Exec(query string, args ...interface{}) string {
return "data"
}
func NewApp() *App {
return &App{}
}
type App struct {
}
func (a *App) GetData(query string, args ...interface{}) string {
data := db.Exec(query, args...)
return data
}
// 不使用依赖注入
func main() {
app := NewApp()
rest := app.GetData("select * from table where id = ?", "1")
println(rest)
}
package main
func NewMySQLClient(url string) *MySQLClient {
return &MySQLClient{url: url}
}
type MySQLClient struct {
url string
}
func (c *MySQLClient) Exec(query string, args ...interface{}) string {
return "data"
}
func NewApp(client *MySQLClient) *App {
return &App{client: client}
}
type App struct {
// App 持有唯一的 MySQLClient 实例
client *MySQLClient
}
func (a *App) GetData(query string, args ...interface{}) string {
data := a.client.Exec(query, args...)
return data
}
// 手动依赖注入
func main() {
client := NewMySQLClient("mysql://blabla")
app := NewApp(client)
rest := app.GetData("select * from table where id = ?", "1")
println(rest)
}
依赖注入 (Dependency Injection，缩写为 DI)，可以理解为一种代码的构造模式（就是写法），按照这样的方式来写，能够让你的代码更加容易维护。
以 Golang 🌟 最多的开源库 wire 为例讲解：https://github.com/google/wire/blob/main/docs/guide.md
wire是由 google 开源的一个供 Go 语言使用的依赖注入代码生成工具。它能够根据你的代码，生成相应的依赖注入 go 代码。
而与其它依靠反射实现的依赖注入工具不同的是，wire 能在编译期（准确地说是代码生成时）如果依赖注入有问题，在代码生成时即可报出来，不会拖到运行时才报，更便于 debug。
go install github.com/google/wire/cmd/wire@latest
以上面手动实现依赖注入为基础，wire 做的工作是帮助开发者完成如下组装过程
client := NewMySQLClient("mysql://blabla")
app := NewApp(client)
而其中用到的 NewMySQLClient、NewApp 在 wire 定义为一个个的 provider，是需要提前由开发者实现的。
func NewMySQLClient(url string) *MySQLClient {
return &MySQLClient{url: url}
}
func NewApp(client *MySQLClient) *App {
return &App{client: client}
}
假设系统中的资源很多，配置很多，出现了如下复杂的初始化流程，人工完成依赖注入则变得复杂：
a := NewA(xxx, yyy) error
b := NewB(ctx, a) error
c := NewC(zzz, a, b) error
d := NewD(www, kkk, a) error
e := NewD(ctx, b, d) error
如下是名为 wire.go 的依赖注入配置文件，是一个只会被 wire 命令行工具处理的 injector 文件，用于声明依赖注入流程。
wire.go:
//go:build wireinject
// +build wireinject
// The build tag makes sure the stub is not built in the final build.
package main
import "github.com/google/wire"
// wireApp init application.
func wireApp(url string) *App {
wire.Build(NewMySQLClient, NewApp)
return nil
}
执行 wire 命令，则在当前目录下生成 wire_gen.go 文件，此时的 wireApp 函数，就等价于最初手动编写的依赖注入流程，可以在真正需要初始化的引入。
wire_gen.go:
// Code generated by Wire. DO NOT EDIT.
//go:generate go run -mod=mod github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject
package main
// Injectors from wire.go:
// wireApp init application.
func wireApp(url string) *App {
mySQLClient := NewMySQLClient(url)
app := NewApp(mySQLClient)
return app
}
这里以 go-kratos 的模版项目为例讲解，是一个 helloworld 服务，我们着重分析其借助 wire 进行依赖注入的部分。
以下 helloworld 模板服务的 interanl 目录的内容：
.
├── biz
│ ├── README.md
│ ├── biz.go
│ └── greeter.go
├── conf
│ ├── conf.pb.go
│ └── conf.proto
├── data
│ ├── README.md
│ ├── data.go
│ └── greeter.go
├── server
│ ├── grpc.go
│ ├── http.go
│ └── server.go
└── service
├── README.md
├── greeter.go
└── service.go
各个目录的关系如图：
data：业务数据访问，包含 cache、db 等封装，实现了 biz 的 repo 接口，data 偏重业务的含义，它所要做的是将领域对象重新拿出来。
biz：业务逻辑的组装层，类似 DDD 的 domain 层，data 类似 DDD 的 repo，repo 接口在这里定义，使用依赖倒置的原则。
service：实现了 api 定义的服务层，类似 DDD 的 application 层，处理 DTO 到 biz 领域实体的转换（DTO -> DO），同时协同各类 biz 交互，但是不应处理复杂逻辑。
server：为http和grpc实例的创建和配置，以及注册对应的 service 。
🌟上图右侧部分，表示了模块之间的依赖关系，可以看到，依赖的注入是逆向的，资源往往被业务模块持有，业务模块则被负责编排业务的应用持有，应用则被负责对外通信的模块持有。
此时在服务启动前的实例化阶段，provider 的定义和注入，本质是这样一种状态：
func main() {
dbClient := NewDBClient()
dataN := NewDataN(dbClient)
dataM := NewDataM(dbClient)
bizA := NewBizA(dataN)
bizB := NewBizB(dataM)
bizC := NewBizC(dataN, dataM)
serviceX := NewService(bizA, bizB, bizC)
server := NewServer(serviceX)
server.httpXXX // 提供 http 服务
server.grpcXXX // 提供 grpc 服务
}
在 helloworld 这个 demo 当中，则是这样定义 provider 的：
// biz 目录
var ProviderSet = wire.NewSet(NewGreeterUsecase)
type GreeterUsecase struct {
repo GreeterRepo
log *log.Helper
}
func NewGreeterUsecase(repo GreeterRepo, logger log.Logger) *GreeterUsecase {
return &GreeterUsecase{repo: repo, log: log.NewHelper(logger)}
}
func (uc *GreeterUsecase) CreateGreeter(ctx context.Context, g *Greeter) (*Greeter, error) {
uc.log.WithContext(ctx).Infof("CreateGreeter: %v", g.Hello)
return uc.repo.Save(ctx, g)
}
// data 目录
var ProviderSet = wire.NewSet(NewData, NewGreeterRepo)
type Data struct {
// TODO wrapped database client
}
func NewData(c *conf.Data, logger log.Logger) (*Data, func(), error) {
cleanup := func() {
log.NewHelper(logger).Info("closing the data resources")
}
return &Data{}, cleanup, nil
}
type greeterRepo struct {
data *Data
log *log.Helper
}
func NewGreeterRepo(data *Data, logger log.Logger) biz.GreeterRepo {
return &greeterRepo{
data: data,
log: log.NewHelper(logger),
}
}
// service 目录
var ProviderSet = wire.NewSet(NewGreeterService)
type GreeterService struct {
v1.UnimplementedGreeterServer
uc *biz.GreeterUsecase
}
func NewGreeterService(uc *biz.GreeterUsecase) *GreeterService {
return &GreeterService{uc: uc}
}
func (s *GreeterService) SayHello(ctx context.Context, in *v1.HelloRequest) (*v1.HelloReply, error) {
g, err := s.uc.CreateGreeter(ctx, &biz.Greeter{Hello: in.Name})
if err != nil {
return nil, err
}
return &v1.HelloReply{Message: "Hello " + g.Hello}, nil
}
// server 目录
var ProviderSet = wire.NewSet(NewGRPCServer, NewHTTPServer)
func NewGRPCServer(c *conf.Server, greeter *service.GreeterService, logger log.Logger) *grpc.Server {
var opts = []grpc.ServerOption{
grpc.Middleware(
recovery.Recovery(),
),
}
if c.Grpc.Network != "" {
opts = append(opts, grpc.Network(c.Grpc.Network))
}
if c.Grpc.Addr != "" {
opts = append(opts, grpc.Address(c.Grpc.Addr))
}
if c.Grpc.Timeout != nil {
opts = append(opts, grpc.Timeout(c.Grpc.Timeout.AsDuration()))
}
srv := grpc.NewServer(opts...)
v1.RegisterGreeterServer(srv, greeter)
return srv
}
在 helloworld 这个 demo 当中，则是这样定义 injector 的：
// wire.go
func wireApp(*conf.Server, *conf.Data, log.Logger) (*kratos.App, func(), error) {
panic(wire.Build(server.ProviderSet, data.ProviderSet, biz.ProviderSet, service.ProviderSet, newApp))
}
最后运行 wire 的到的完成注入的文件如下：
// wire_gen.go
func wireApp(confServer *conf.Server, confData *conf.Data, logger log.Logger) (*kratos.App, func(), error) {
dataData, cleanup, err := data.NewData(confData, logger)
if err != nil {
return nil, nil, err
}
greeterRepo := data.NewGreeterRepo(dataData, logger)
greeterUsecase := biz.NewGreeterUsecase(greeterRepo, logger)
greeterService := service.NewGreeterService(greeterUsecase)
grpcServer := server.NewGRPCServer(confServer, greeterService, logger)
httpServer := server.NewHTTPServer(confServer, greeterService, logger)
app := newApp(logger, grpcServer, httpServer)
return app, func() {
cleanup()
}, nil
}
生成代码之后，则可以像使用普通的 golang 函数一样，使用这个 wire_gen.go 文件内的 wireApp 函数实例化一个 helloworld 服务
func main() {
flag.Parse()
logger := log.With(log.NewStdLogger(os.Stdout),
// ...
)
c := config.New(
// ...
)
defer c.Close()
// ...
app, cleanup, err := wireApp(bc.Server, bc.Data, logger)
if err != nil {
panic(err)
}
defer cleanup()
// start and wait for stop signal
if err := app.Run(); err != nil {
panic(err)
}
}
参见 wire 的文档，自己用几遍就明白了，这里举几个例子：
func ProvideBaz(ctx context.Context, bar Bar) (Baz, error) {
if bar.X == 0 {
return Baz{}, errors.New("cannot provide baz when bar is zero")
}
return Baz{X: bar.X}, nil
}
var SuperSet = wire.NewSet(ProvideFoo, ProvideBar, ProvideBaz)
type Fooer interface {
Foo() string
}
type MyFooer string
func (b *MyFooer) Foo() string {
return string(*b)
}
func provideMyFooer() *MyFooer {
b := new(MyFooer)
*b = "Hello, World!"
return b
}
type Bar string
func provideBar(f Fooer) string {
// f will be a *MyFooer.
return f.Foo()
}
var Set = wire.NewSet(
provideMyFooer,
wire.Bind(new(Fooer), new(*MyFooer)),
provideBar)
Spring Boot的依赖注入（DI）和Golang开源库Wire的依赖注入在设计思路上存在一些相同点和不同点。以下是对这些相同点和不同点的分析：
kratos：https://go-kratos.dev/en/docs/getting-started/start/
wire：https://github.com/google/wire/blob/main/_tutorial/README.md