依赖注入 与 Wire 的使用

控制反转和依赖注入

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI）。依赖注入是天生灵活和松散耦合代码的标准技能，通过明确地向组件提供它们所需要的所有依赖关系。在 Go 中通常采用将依赖项作为参数传递给构造函数的情势：
构造函数NewBookRepo在创建BookRepo时需要从外部将依赖项db作为参数传入，我们在NewBookRepo中无需关注db的创建逻辑，实现了代码解耦。

1. // NewBookRepo 创建BookRepo的构造函数
2. func NewBookRepo(db *gorm.DB) *BookRepo {
3.         return &BookRepo{db: db}
4. }

复制代码

区别于控制反转，如果在NewBookRepo函数中自行创建相干依赖，这将导致代码高度耦合并且难以维护和调试。

1. // NewBookRepo 创建BookRepo的构造函数
2. func NewBookRepo() *BookRepo {
3.   db, _ := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{})
4.         return &BookRepo{db: db}
5. }

复制代码

为什么需要依赖注入工具

现在我们已经知道了应该在开辟中尽可能地使用控制反转和依赖注入将程序解耦开来，从而写出灵活和易测试的程序。
在小型应用程序中，我们可以自行创建依赖并手动注入。但是在一个大型应用程序中，手动去实现所有依赖的创建和注入就会比较繁琐。
例如，在一些常见的HTTP服务中，会根据业务需要划分出差别的代码层：

1. ├── internal
2. │   ├── conf
3. │   │   └── conf.go
4. │   ├── data
5. │   │   └── data.go
6. │   ├── server
7. │   │   └── server.go
8. │   └── service
9. │       └── service.go
10. └── main.go

复制代码

我们的服务需要有一个配置，指定工作模式、连接的数据库和监听端口等信息。

1. // conf/conf.go
3. // NewDefaultConfig 返回默认配置，不需要依赖
4. func NewDefaultConfig() *Config {...}

复制代码

我们这里界说了一个默认配置，固然后续可以支持从配置文件或环境变量读取配置信息。
在程序的data层，需要界说一个连接数据库的函数，它依赖上面界说的Config并返回一个*gorm.DB（这里使用gorm连接数据库）。

1. // data/data.go
3. // NewDB 返回数据库连接对象
4. func NewDB(cfg *conf.Config) (*gorm.DB, error) {...}

复制代码

同时界说一个BookRepo，它有一些数据操作相干的方法。它的构造函数NewBookRepo依赖*gorm.DB，并返回一个*BookRepo。

1. // data/data.go
3. type BookRepo struct {
4.         db *gorm.DB
5. }
7. func NewBookRepo(db *gorm.DB) *BookRepo {...}

复制代码

Service层位于data层和Server层的中心，它负责实现对外服务。其中构造函数 NewBookService 依赖Config和BookRepo。

1. // service/service.go
3. type BookService struct {
4.         config *conf.Config
5.         repo   *data.BookRepo
6. }
8. func NewBookService(cfg *conf.Config, repo *data.BookRepo) *BookService {...}

复制代码

server层又有一个NewServer构造函数，它依赖外部传入Config和BookService。

1. // server/server.go
3. type Server struct {
4.         config  *conf.Config
5.         service *service.BookService
6. }
8. func NewServer(cfg *conf.Config, srv *service.BookService) *Server {...}

复制代码

在main.go文件中又依赖Server创建一个app。

1. // main.go
3. type Server interface {
4.         Run()
5. }
7. type App struct {
8.         server Server
9. }
11. func newApp(server Server) *App {...}

复制代码

由于在程序中界说了大量需要依赖注入的构造函数，程序的main函数中会出现以下情形。所有依赖的创建和次序都需要手动维护。

1. // main.go
3. func main() {
4.         cfg := conf.NewDefaultConfig()
5.         db, _ := data.NewDB(cfg)
6.         repo := data.NewBookRepo(db)
7.         bookSrv := service.NewBookService(cfg, repo)
8.         server := server.NewServer(cfg, bookSrv)
9.         app := newApp(server)
11.         app.Run()
12. }

复制代码

我们确实需要一个工具来办理这类题目。
Wire

Wire 是一个专为依赖注入（Dependency Injection）设计的代码天生工具，它可以主动天生用于初始化各种依赖关系的代码，从而帮助我们更轻松地管理和注入依赖关系。
Wire 安装

我们可以执行以下下令来安装 Wire 工具：

1. $ go install github.com/google/wire/cmd/wire@latest

复制代码

安装之前请确保已将 $GOPATH/bin 添加到环境变量 $PATH 里。
Wire 的根本使用

前置代码准备

固然我们在前面已经通过 go install 下令安装了 Wire 下令行工具，但在具体项目中，我们仍然需要通过以下下令安装项目所需的 Wire 依赖，以便团结 Wire 工具天生代码：

1. $ go get github.com/google/wire@latest

复制代码

接下来，让我们模拟一个简单的 web 博客项目，编写查询文章接口的相干代码，并使用 Wire 工具天生代码。
项目的目录结构如下：

1. .
2. ├── ioc
3. │   └── article.go
4. ├── main.go
5. ├── service
6. │   └── article.go
7. ├── web
8. │   └── article.go
9. └── wire.go

复制代码

首先，我们先界说相干类型与方法，并提供对应的 初始化函数：

• 界说 PostHandler 结构体，创建注册路由的方法 RegisterRoutes 和查询文章路由处置惩罚的方法 GetPostById 以及初始化的函数 NewPostHandler，并且它依赖于 IPostService 接口：
  

1. type PostHandler struct {
2.         serv service.IPostService
3. }
5. func (h *PostHandler) RegisterRoutes(engine *gin.Engine) {
6.         engine.GET("/post/:id", h.GetPostById)
7. }
9. func (h *PostHandler) GetPostById(ctx *gin.Context) {
10.         content := h.serv.GetPostById(ctx, ctx.Param("id"))
11.         ctx.String(http.StatusOK, content)
12. }
14. func NewPostHandler(serv service.IPostService) *PostHandler {
15.         return &PostHandler{serv: serv}
16. }

复制代码

• 界说 IPostService 接口，并提供了一个具体实现 PostService，接着创建 GetPostById 方法，用于处置惩罚查询文章的逻辑，然后提供初始化函数 NewPostService，该函数返回 IPostService 接口类型：
  

1. type IPostService interface {
2.         GetPostById(ctx context.Context, id string) string
3. }
5. var _ IPostService = (*PostService)(nil)
7. type PostService struct {
8. }
10. func (s *PostService) GetPostById(ctx context.Context, id string) string {
11.         return "欢迎访问博客"
12. }
14. func NewPostService() IPostService {
15.         return &PostService{}
16. }

复制代码

• 界说一个初始化 gin.Engine 函数 NewGinEngineAndRegisterRoute，该函数依赖于 *handler.PostHandler 类型，函数内部调用相干 handler 结构体的方法创建路由：
  

1. func NewGinEngineAndRegisterRoute(postHandler *web.PostHandler) *gin.Engine {
2.     engine := gin.Default()
3.     postHandler.RegisterRoutes(engine)
4.     return engine
5. }

复制代码

使用 Wire 工具天生代码

前置代码已经准备好了，接下来我们编写焦点代码，以便 Wire 工具能天生相应的依赖注入代码。

• 首先我们需要创建一个 wire 的配置文件，通常命名为 wire.go。在这个文件里，我们需要界说一个大概多个注入器函数（Injector 函数，接下来的内容会对其进行解释），以便指引 Wire 工具天生代码。
  

1. func InitializeApp() *gin.Engine {
2.     wire.Build(
3.         web.NewPostHandler,
4.         service.NewPostService,
5.         ioc.NewGinEngineAndRegisterRoute,
6.     )
8.     return &gin.Engine{}
9. }

复制代码

在上述代码中，我们界说了一个用于初始化 gin.Engine 的注入器函数，在该函数内部，我们使用了 wire.Build 方法来声明依赖关系，其中包罗 PostHandler、PostService 和 InitGinEngine 作为依赖的构造函数。
wire.Build 的作用是 连接或绑定我们之前界说的所有初始化函数。当我们运行 wire 工具来天生代码时，它就会根据这些依赖关系来主动创建和注入所需的实例。
注意：文件首行必须加上 //go:build wireinject 或 // +build wireinject(go 1.18 之前的版本使用) 注释，作用是只有在使用 wire 工具时才会编译这部分代码，其他情况下忽略。

• 接下来在 wire.go 文件所处目录下执行 wire 下令，天生 wire_gen.go 文件，内容如下所示：
  

1. // Code generated by Wire. DO NOT EDIT.
3. //go:generate go run github.com/google/wire/cmd/wire
4. //go:build !wireinject
5. // +build !wireinject
7. package main
9. import (
10.         "github.com/gin-gonic/gin"
11.         "golang-example/wire/blog/ioc"
12.         "golang-example/wire/blog/service"
13.         "golang-example/wire/blog/web"
14. )
16. // Injectors from wire.go:
18. func InitializeApp() *gin.Engine {
19.         iPostService := service.NewPostService()
20.         postHandler := web.NewPostHandler(iPostService)
21.         engine := ioc.NewGinEngineAndRegisterRoute(postHandler)
22.         return engine
23. }

复制代码

天生的代码和我们手写区别不大，当我们的组件很多，依赖关系复杂的时间，我们才会感觉到 Wire 工具的好处。
Wire 的焦点概念

Wire 有两个焦点概念：提供者（providers）和注入器（injectors）。
Wire 提供者（providers）

提供者：一个可以产生值的函数，也就是有返回值的函数。例如入门代码里的 NewPostHandler 函数：

1. func NewPostHandler(serv service.IPostService) *PostHandler {  
2.         return &PostHandler{serv: serv}  
3. }

复制代码

返回值不仅限于一个，如果有需要的话，可以额外添加一个 error 的返回值。
如果提供者过多的时间，我们还可以以分组的情势进行连接，例如将 post 相干的 handler 和 service 进行组合：

1. package web  
2.   
3. var PostSet = wire.NewSet(NewPostHandler, service.NewPostService)

复制代码

使用 wire.NewSet 函数将提供者进行分组，该函数返回一个 ProviderSet 结构体。不仅云云，wire.NewSet 还能对多个 ProviderSet 进行分组 wire.NewSet(PostSet, XxxSet) 。
对于之前的 InitializeApp 函数，我们可以这样升级：

1. func InitializeAppV2() *gin.Engine {  
2.         wire.Build(  
3.                 web.PostSet,  
4.                 ioc.NewGinEngineAndRegisterRoute,  
5.         )  
6.         return &gin.Engine{}  
7. }

复制代码

然后通过 Wire 下令天生代码，和之前的效果一致。
Wire 注入器（injectors）

注入器（injectors）的作用是将所有的提供者（providers）连接起来，回顾一下我们之前的代码：

1. func InitializeApp() *gin.Engine {  
2.         wire.Build(  
3.                 web.NewPostHandler,  
4.                 service.NewPostService,  
5.                 ioc.NewGinEngineAndRegisterRoute,  
6.         )  
7.         return &gin.Engine{}  
8. }

复制代码

InitializeApp 函数就是一个注入器，函数内部通过 wire.Build 函数连接所有的提供者，然后返回 &gin.Engine{}，该返回值现实上并没有使用到，只是为了满意编译器的要求，避免报错而已，真正的返回值来自 ioc.NewGinEngineAndRegisterRoute。
Wire 高级应用

绑定接口

回顾我们之前编写的代码：

1. package web
3. ···
5. func NewPostHandler(serv service.IPostService) *PostHandler {
6.     return &PostHandler{serv: serv}
7. }
9. ···
11. pakacge service
13. ···
15. func NewPostService() IPostService {
16.     return &PostService{}
17. }
19. ···

复制代码

NewPostHandler 函数依赖于 service.IPostService 接口，NewPostService 函数返回的是 IPostService 接口的值，这两个地方的类型匹配，因此 Wire 工具可以大概精确识别并天生代码。然而，这并不是推荐的最佳实践。由于在 Go 中的 最佳实践 是返回 具体的类型 的值，所以最好让 NewPostService 返回具体类型 PostService 的值：

1. func NewPostService() *PostService {  
2.         return &PostService{}  
3. }

复制代码

但是这样，Wire 工具将认为 IPostService 接口类型与 PostService 类型不匹配，导致天生代码失败。因此我们需要修改注入器的代码：

1. func InitializeApp() *gin.Engine {  
2.         wire.Build(  
3.                 web.NewPostHandler,  
4.                 service.NewPostService,  
5.                 ioc.NewGinEngineAndRegisterRoute,  
6.                 wire.Bind(new(service.IPostService), new(*service.PostService)),  
7.         )  
8.         return &gin.Engine{}  
9. }

复制代码

使用 wire.Bind 来建立接口类型和具体的实现类型之间的绑定关系，这样 Wire 工具就可以根据这个绑定关系进行类型匹配并天生代码。
wire.Bind 函数的第一个参数是指向所需接口类型值的指针，第二个实参是指向实现该接口的类型值的指针。
结构体提供者（Struct Providers）

Wire 库有一个函数是 wire.Struct，它能根据现有的类型进行构造结构体，我们来看看下面的例子：

1. package main
3. type Name string
5. func NewName() Name {
6.     return"Jack"
7. }
9. type PublicAccount string
11. func NewPublicAccount() PublicAccount {
12.     return"Hello World"
13. }
15. type User struct {
16.     MyName          Name
17.     MyPublicAccount PublicAccount
18. }
20. func InitializeUser() *User {
21.     wire.Build(
22.        NewName,
23.        NewPublicAccount,
24.        wire.Struct(new(User), "MyName", "MyPublicAccount"),
25.     )
26.     return &User{}
27. }

复制代码

上述代码中，首先界说了自界说类型 Name 和 PublicAccount 以及结构体类型 User，并分别提供了 Name 和 PublicAccount 的初始化函数（providers）。然后界说一个注入器（injectors）InitializeUser，用于构造连接提供者并构造 *User 实例。
使用 wire.Struct 函数需要传递两个参数，第一个参数是结构体类型的指针值，另一个参数是一个可变参数，表现需要注入的结构体字段的名称集。
根据上述代码，使用 Wire 工具天生的代码如下所示：

1. func InitializeUser() *User {
2.     name := NewName()
3.     publicAccount := NewPublicAccount()
4.     user := &User{
5.        MyName:          name,
6.        MyPublicAccount: publicAccount,
7.     }
8.     return user
9. }

复制代码

如果我们不想返回指针类型，只需要修改 InitializeUser 函数的返回值为非指针即可。
绑定值

有时间，我们可以在注入器中通过 值表达式 给一个类型进行赋值，而不是依赖提供者（providers）。

1. func InjectUser() User {  
2.         wire.Build(wire.Value(User{MyName: "Jack"}))  
3.         return User{}  
4. }

复制代码

在上述代码中，使用 wire.Value 函数通过表达式直接指定 MyName 的值，天生的代码如下所示：

1. func InjectUser() User {
2.     user := _wireUserValue
3.     return user
4. }
6. var (
7.     _wireUserValue = User{MyName: "Jack"}
8. )

复制代码

需要注意的是，值表达式将被复制到天生的代码文件中。
对于接口类型，可以使用 InterfaceValue：

1. func InjectPostService() service.IPostService {
2.     wire.Build(wire.InterfaceValue(new(service.IPostService), &service.PostService{}))
3.     return nil
4. }

复制代码

使用结构体字段作为提供者（providers）

有些时间，你可以使用结构体的某个字段作为提供者，从而天生一个类似 GetXXX 的函数。

1. func GetUserName() Name {
2.     wire.Build(
3.        NewUser,
4.        wire.FieldsOf(new(User), "MyName"),
5.     )
6.     return ""
7. }

复制代码

你可以使用 wire.FieldsOf 函数添加任意字段，天生的代码如下所示：

1. func GetUserName() Name {
2.     user := NewUser()
3.     name := user.MyName
4.     return name
5. }
7. func NewUser() User {
8.     return User{MyName: Name("Jack"), MyPublicAccount: PublicAccount("HelloWorld")}
9. }

复制代码

清理函数

如果一个提供者创建了一个需要清理的值（例如关闭一个文件），那么它可以返回一个闭包来清理资源。注入器会用它来给调用者返回一个聚合的清理函数，大概在注入器实现中稍后调用的提供商返回错误时清理资源。
并且 Wire 对 Provider 的返回值个数及次序有以下限定：

• 第一个返回值是需要天生的对象
  
• 如果有 2 个返回值，第二个返回值必须是 func() 或 error
  
• 如果有 3 个返回值，第二个返回值必须是 func()，而第三个返回值必须是
  

1. // db.go
2. func InitGormDB()(*gorm.DB, func(), error) {
3.     // 初始化db链接
4.     // ...
5.     cleanFunc := func(){
6.         db.Close()
7.     }
9.     return db, cleanFunc, nil
10. }
12. // wire.go
13. func BuildInjector() (*Injector, func(), error) {
14.    wire.Build(
15.       common.InitGormDB,
16.       // ...
17.       NewInjector
18.    )
20.    return new(Injector), nil, nil
21. }
23. // 生成的wire_gen.go
24. func BuildInjector() (*Injector, func(), error) {
25.    db, cleanup, err := common.InitGormDB()
26.    // ...
27.    return injector, func(){
28.        // 所有provider的清理函数都会在这里
29.        cleanup()
30.    }, nil
31. }
33. // main.go
34. injector, cleanFunc, err := app.BuildInjector()
35. defer cleanFunc()

复制代码

备用注入器语法

如果你不喜欢将类似这种写法 → return &gin.Engine{} 放在你的注入器函数声明的末端，你可以用 panic 来更简洁地写它:

1. func InitializeGin() *gin.Engine {  
2.         panic(wire.Build(/* ... */))  
3. }

复制代码

总结

在本文中，我们具体探究了 Go Wire 工具的根本用法和高级特性。它是一个专为依赖注入设计的代码天生工具，它不仅提供了基础的依赖解析和代码天生功能，还支持多种高级用法，如接口绑定和构造结构体。
依赖注入的设计模式应用非常广泛，Wire 工具让依赖注入在 Go 语言中变得更简单。
本文的所有代码在这里。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。