深入浅出go依赖注入工具Wire的使用
前言
在日常项目开发中，我们经常会使用到依赖注入的设计模式，目的是为了降低代码组件之间的耦合度，提高代码的可维护性、可扩展性和可测试性。
但随着项目规模的增长，组件之间的依赖关系变得复杂，手动管理它们之间的依赖关系可能会很繁琐。为了简化这个过程，我们可以利用依赖注入代码生成工具，它可以自动为我们生成所需的代码，从而减轻了手动处理依赖注入的繁重工作。
Go 语言有许多依赖注入的工具，而本文将深入探讨一个备受欢迎的 Go 语言依赖注入工具—— Wire。
准备好了吗？准备一杯你最喜欢的咖啡或茶，随着本文一探究竟吧。
Wire
Wire 是一个专为依赖注入（Dependency Injection）设计的代码生成工具，它可以自动生成用于初始化各种依赖关系的代码，从而帮助我们更轻松地管理和注入依赖关系。
Wire 安装
我们可以执行以下命令来安装 Wire 工具：
go install github.com/google/wire/cmd/wire@latest
安装之前请确保已将 $GOPATH/bin 添加到环境变量 $PATH 里。
Wire 的基本使用
前置代码准备
虽然我们在前面已经通过 go install 命令安装了 Wire 命令行工具，但在具体项目中，我们仍然需要通过以下命令安装项目所需的 Wire 依赖，以便结合 Wire 工具生成代码：
go get github.com/google/wire@latest
接下来，让我们模拟一个简单的 web 博客项目，编写查询文章接口的相关代码，并使用 Wire 工具生成代码。
首先，我们先定义相关类型与方法，并提供对应的 初始化函数：
定义 PostHandler 结构体，创建注册路由的方法 RegisterRoutes 和查询文章路由处理的方法 GetPostById 以及初始化的函数 NewPostHandler，并且它依赖于 IPostService 接口：
package handler
import (
"chenmingyong0423/blog/tutorial-code/wire/internal/post/service"
"github.com/gin-gonic/gin"
"net/http"
)
type PostHandler struct {
serv service.IPostService
}
func (h *PostHandler) RegisterRoutes(engine *gin.Engine) {
engine.GET("/post/:id", h.GetPostById)
}
func (h *PostHandler) GetPostById(ctx *gin.Context) {
content := h.serv.GetPostById(ctx, ctx.Param("id"))
ctx.String(http.StatusOK, content)
}
func NewPostHandler(serv service.IPostService) *PostHandler {
return &PostHandler{serv: serv}
}定义 IPostService 接口，并提供了一个具体实现 PostService，接着创建 GetPostById 方法，用于处理查询文章的逻辑，然后提供初始化函数 NewPostService，该函数返回 IPostService 接口类型：
package service
import (
"context"
"fmt"
)
type IPostService interface {
GetPostById(ctx context.Context, id string) string
}
var _ IPostService = (*PostService)(nil)
type PostService struct {
}
func (s *PostService) GetPostById(ctx context.Context, id string) string {
return fmt.Sprint("欢迎关注本掘金号，作者：陈明勇")
}
func NewPostService() IPostService {
return &PostService{}
}定义一个初始化 gin.Engine 函数 NewGinEngineAndRegisterRoute，该函数依赖于 *handler.PostHandler 类型，函数内部调用相关 handler 结构体的方法创建路由：
package ioc
import (
"chenmingyong0423/blog/tutorial-code/wire/internal/post/handler"
"github.com/gin-gonic/gin"
)
func NewGinEngineAndRegisterRoute(postHandler *handler.PostHandler) *gin.Engine {
engine := gin.Default()
postHandler.RegisterRoutes(engine)
return engine
}使用 Wire 工具生成代码
前置代码已经准备好了，接下来我们编写核心代码，以便 Wire 工具能生成相应的依赖注入代码。
首先我们需要创建一个 wire 的配置文件，通常命名为 wire.go。在这个文件里，我们需要定义一个或者多个注入器函数（Injector 函数，接下来的内容会对其进行解释），以便指引 Wire 工具生成代码。
//go:build wireinject
package wire
import (
"chenmingyong0423/blog/tutorial-code/wire/internal/post/handler"
"chenmingyong0423/blog/tutorial-code/wire/internal/post/service"
"chenmingyong0423/blog/tutorial-code/wire/ioc"
"github.com/gin-gonic/gin"
"github.com/google/wire"
)
func InitializeApp() *gin.Engine {
wire.Build(
handler.NewPostHandler,
service.NewPostService,
ioc.NewGinEngineAndRegisterRoute,
)
return &gin.Engine{}
}在上述代码中，我们定义了一个用于初始化 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 文件，内容如下所示：
// Code generated by Wire. DO NOT EDIT.
//go:generate go run github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject
package wire
import (
"chenmingyong0423/blog/tutorial-code/wire/internal/post/handler"
"chenmingyong0423/blog/tutorial-code/wire/internal/post/service"
"chenmingyong0423/blog/tutorial-code/wire/ioc"
"github.com/gin-gonic/gin"
)
// Injectors from wire.go:
func InitializeApp() *gin.Engine {
iPostService := service.NewPostService()
postHandler := handler.NewPostHandler(iPostService)
engine := ioc.NewGinEngineAndRegisterRoute(postHandler)
return engine
}生成的代码和我们手写区别不大，当我们的组件很多，依赖关系复杂的时候，我们才会感觉到 Wire 工具的好处。
Wire 的核心概念
Wire 有两个核心概念：提供者（providers）和注入器（injectors）。
Wire 提供者（providers）
提供者：一个可以产生值的函数，也就是有返回值的函数。例如入门代码里的 NewPostHandler 函数：
func NewPostHandler(serv service.IPostService) *PostHandler {
return &PostHandler{serv: serv}
}返回值不仅限于一个，如果有需要的话，可以额外添加一个 error 的返回值。
如果提供者过多的时候，我们还可以以分组的形式进行连接，例如将 post 相关的 handler 和 service 进行组合：
package handler var PostSet = wire.NewSet(NewPostHandler, service.NewPostService)
使用 wire.NewSet 函数将提供者进行分组，该函数返回一个 ProviderSet 结构体。不仅如此，wire.NewSet 还能对多个 ProviderSet 进行分组 wire.NewSet(PostSet, XxxSet) 。
对于之前的 InitializeApp 函数，我们可以这样升级：
//go:build wireinject
package wire
func InitializeAppV2() *gin.Engine {
wire.Build(
handler.PostSet,
ioc.NewGinEngineAndRegisterRoute,
)
return &gin.Engine{}
}然后通过 Wire 命令生成代码，和之前的结果一致。
Wire 注入器（injectors）
注入器（injectors）的作用是将所有的提供者（providers）连接起来，回顾一下我们之前的代码：
func InitializeApp() *gin.Engine {
wire.Build(
handler.NewPostHandler,
service.NewPostService,
ioc.NewGinEngineAndRegisterRoute,
)
return &gin.Engine{}
}InitializeApp 函数就是一个注入器，函数内部通过 wire.Build 函数连接所有的提供者，然后返回 &gin.Engine{}，该返回值实际上并没有使用到，只是为了满足编译器的要求，避免报错而已，真正的返回值来自 ioc.NewGinEngineAndRegisterRoute。
Wire 的高级用法
绑定接口
回顾我们之前编写的代码：
package handler
···
func NewPostHandler(serv service.IPostService) *PostHandler {
return &PostHandler{serv: serv}
}
···
pakacge service
···
func NewPostService() IPostService {
return &PostService{}
}
···NewPostHandler 函数依赖于 service.IPostService 接口，NewPostService 函数返回的是 IPostService 接口的值，这两个地方的类型匹配，因此 Wire 工具能够正确识别并生成代码。然而，这并不是推荐的最佳实践。因为在 Go 中的 最佳实践 是返回 具体的类型 的值，所以最好让 NewPostService 返回具体类型 PostService 的值：
func NewPostServiceV2() *PostService {
return &PostService{}
}但是这样，Wire 工具将认为 IPostService 接口类型与 PostService 类型不匹配，导致生成代码失败。因此我们需要修改注入器的代码：
func InitializeAppV3() *gin.Engine {
wire.Build(
handler.NewPostHandler,
service.NewPostServiceV2,
ioc.NewGinEngineAndRegisterRoute,
wire.Bind(new(service.IPostService), new(*service.PostService)),
)
return &gin.Engine{}
}使用 wire.Bind 来建立接口类型和具体的实现类型之间的绑定关系，这样 Wire 工具就可以根据这个绑定关系进行类型匹配并生成代码。
wire.Bind 函数的第一个参数是指向所需接口类型值的指针，第二个实参是指向实现该接口的类型值的指针。
结构体提供者（Struct Providers）
Wire 库有一个函数是 wire.Struct，它能根据现有的类型进行构造结构体，我们来看看下面的例子：
package main
type Name string
func NewName() Name {
return "陈明勇"
}
type PublicAccount string
func NewPublicAccount() PublicAccount {
return "公众号：Go技术干货"
}
type User struct {
MyName Name
MyPublicAccount PublicAccount
}
func InitializeUser() *User {
wire.Build(
NewName,
NewPublicAccount,
wire.Struct(new(User), "MyName", "MyPublicAccount"),
)
return &User{}
}上述代码中，首先定义了自定义类型 Name 和 PublicAccount 以及结构体类型 User，并分别提供了 Name 和 PublicAccount 的初始化函数（providers）。然后定义一个注入器（injectors）InitializeUser，用于构造连接提供者并构造 *User 实例。
使用 wire.Struct 函数需要传递两个参数，第一个参数是结构体类型的指针值，另一个参数是一个可变参数，表示需要注入的结构体字段的名称集。
根据上述代码，使用 Wire 工具生成的代码如下所示：
func InitializeUser() *User {
name := NewName()
publicAccount := NewPublicAccount()
user := &User{
MyName: name,
MyPublicAccount: publicAccount,
}
return user
}如果我们不想返回指针类型，只需要修改 InitializeUser 函数的返回值为非指针即可。
绑定值
有时候，我们可以在注入器中通过 值表达式 给一个类型进行赋值，而不是依赖提供者（providers）。
func InjectUser() User {
wire.Build(wire.Value(User{MyName: "陈明勇"}))
return User{}
}在上述代码中，使用 wire.Value 函数通过表达式直接指定 MyName 的值，生成的代码如下所示：
func InjectUser() User {
user := _wireUserValue
return user
}
var (
_wireUserValue = User{MyName: "陈明勇"}
)需要注意的是，值表达式将被复制到生成的代码文件中。
对于接口类型，可以使用 InterfaceValue：
func InjectPostService() service.IPostService {
wire.Build(wire.InterfaceValue(new(service.IPostService), &service.PostService{}))
return nil
}使用结构体字段作为提供者（providers）
有些时候，你可以使用结构体的某个字段作为提供者，从而生成一个类似 GetXXX 的函数。
func GetUserName() Name {
wire.Build(
NewUser,
wire.FieldsOf(new(User), "MyName"),
)
return ""
}你可以使用 wire.FieldsOf 函数添加任意字段，生成的代码如下所示：
func GetUserName() Name {
user := NewUser()
name := user.MyName
return name
}
func NewUser() User {
return User{MyName: Name("陈明勇"), MyPublicAccount: PublicAccount("公众号：Go技术干货")}
}清理函数
如果一个提供者创建了一个需要清理的值（例如关闭一个文件），那么它可以返回一个闭包来清理资源。注入器会用它来给调用者返回一个聚合的清理函数，或者在注入器实现中稍后调用的提供商返回错误时清理资源。
func provideFile(log Logger, path Path) (*os.File, func(), error) {
f, err := os.Open(string(path))
if err != nil {
return nil, nil, err
}
cleanup := func() {
if err := f.Close(); err != nil {
log.Log(err)
}
}
return f, cleanup, nil
}备用注入器语法
如果你不喜欢将类似这种写法 → return &gin.Engine{} 放在你的注入器函数声明的末尾，你可以用 panic 来更简洁地写它:
func InitializeGin() *gin.Engine {
panic(wire.Build(/* ... */))
}小结
在本文中，我们详细探讨了 Go Wire 工具的基本用法和高级特性。它是一个专为依赖注入设计的代码生成工具，它不仅提供了基础的依赖解析和代码生成功能，还支持多种高级用法，如接口绑定和构造结构体。
依赖注入的设计模式应用非常广泛，Wire 工具让依赖注入在 Go 语言中变得更简单。
以上就是深入浅出go依赖注入工具Wire的使用的详细内容，更多关于go依赖注入工具Wire的资料请关注脚本之家其它相关文章！
相关文章
在本文中，我们将深入探讨 flag 标准库的实现原理和使用技巧，以帮助读者更好地理解和掌握该库的使用方法，文中的示例代码讲解详细，感兴趣的可以了解一下2023-04-04
这篇文章主要介绍了golang获得一个变量类型的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-05-05
msgpack是一个非常受欢迎的Go序列化库,具有很好的跨语言支持，这篇文章主要介绍了golang 用msgpack高效序列化的相关知识,需要的朋友可以参考下2023-05-05
无论是优雅关机还是优雅重启归根结底都是通过监听特定系统信号，然后执行一定的逻辑处理保障当前系统正在处理的请求被正常处理后再关闭当前进程，这篇文章主要介绍了Go实现优雅关机与平滑重启 ,需要的朋友可以参考下2022-10-10
这篇文章主要介绍了Go开发神器Air热加载使用实例探究,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2024-01-01
最近对golang处理音视频很感兴趣，对golang音视频常用库goav进行了一番研究。自己写了一个wav转采样率的功能。给大家分享一下，中间遇到了不少坑，解决的过程中还是蛮有意思的，希望大家能喜欢2022-12-12
Golang Printf,Sprintf,Fprintf 格式化详解
这篇文章主要介绍了Golang Printf,Sprintf,Fprintf 格式化详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-03-03
这篇文章主要介绍了golang的time包:秒、毫秒、纳秒时间戳输出方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-12-12
在Golang中，异常处理是非常重要的一部分，能够有效地控制和处理代码中的异常情况。通过Golang的异常处理机制，可以优雅地捕获和处理异常，保障代码的可靠性和稳定性。同时，Golang还提供了丰富的工具和API，帮助开发者更加轻松地进行异常处理2023-04-04
这篇文章主要介绍了Goland字符串格式化样式中“\r“的作用,"\r"起的作用是回到行首，当前控制台输出，输出完以后回到当前行的行首，本文给大家介绍的非常详细，需要的朋友可以参考下2023-04-04
最新评论