Golang 依赖注入设计哲学｜12.6K ? 的依赖注入库 wire

零

5294
文章

44
评论

2024 年 7 月 3 日09:41:22Golang教程评论85字数 8973阅读29分54秒阅读模式2024 年 7 月 3 日

一、前言

线上项目往往依赖非常多的具备特定能力的资源，如：DB、MQ、各种中间件，以及随着项目业务的复杂化，单一项目内，业务模块也逐渐增多，如何高效、整洁管理各种资源十分重要。

本文从“术”层面，讲述“依赖注入”的实现，带你体会其对于整洁架构 & DDD 等设计思想的落地，起到的支撑作用。文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

涉及内容：文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

最热门的 golang 依赖注入库，GitHub ? 12.5k：github.com/google/wire

GiuHub ? 22.5k 的 golang 微服务框架 kratos 默认使用 wire 作为依赖注入方式：github.com/go-kratos/k…
Spring Boot 与 Golang 的依赖注入对比
依赖注入的设计哲学

? B站账号：白泽talk，绝大部分博客内容都将会通过视频讲解，不过文章一般是先于视频发布文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html
文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html
白泽的开源 Golang 学习仓库：github.com/BaiZe1998/g…，用于文章归档 & 聚合博客代码案例文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html
公众号【白泽talk】，本期内容的 pdf 版本，可以关注公众号，回复【依赖注入】获得，往期资源的获取，都是类似的方式。文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

二、What

? 本文所涉及编写的代码，已收录于 github.com/BaiZe1998/g… 目录文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

一句话概括：实例 A 的创建，依赖于实例 B 的创建，且在实例 A 的生命周期内，持有对实例 B 的访问权限。文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

2.1 案例分析

依赖注入（Dependency Injection, DI），以 Golang 为例，左侧为手动完成依赖注入，右侧为不使用依赖注入：文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

? 不使用依赖注入风险：文章源自灵鲨社区-https://www.0s52.com/bcjc/golangjc/16543.html

全局变量十分不安全，存在覆写的可能
资源散落在各处，可能重复创建，浪费内存，后续维护能力极差
提高循环依赖的风险
全局变量的引入提高单元测试的成本

不使用依赖注入 demo

复制代码

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)
}

手动依赖注入 demo

复制代码

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)
}

三、Why

依赖注入 (Dependency Injection，缩写为 DI)，可以理解为一种代码的构造模式（就是写法），按照这样的方式来写，能够让你的代码更加容易维护。

四、How

4.1 Golang 依赖注入

以 Golang ? 最多的开源库 wire 为例讲解：github.com/google/wire…

wire是由 google 开源的一个供 Go 语言使用的依赖注入代码生成工具。它能够根据你的代码，生成相应的依赖注入 go 代码。

而与其它依靠反射实现的依赖注入工具不同的是，wire 能在编译期（准确地说是代码生成时）如果依赖注入有问题，在代码生成时即可报出来，不会拖到运行时才报，更便于 debug。

Install：

bash

复制代码

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

provider: a function that can produce a value

以上面手动实现依赖注入为基础，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

injector: a function that calls providers in dependency order

如下是名为 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
}

4.2 针对复杂项目的依赖注入设计哲学

这里以 go-kratos 的模版项目为例讲解，是一个 helloworld 服务，我们着重分析其借助 wire 进行依赖注入的部分。

以下 helloworld 模板服务的 interanl 目录的内容：

shell

复制代码

.
├── 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)
    }
}

4.3 wire 的更多用法

参见 wire 的文档，自己用几遍就明白了，这里举几个例子：

定义携带 error 返回值的 provider

复制代码

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
}

provider 集合：方便组织多个 provider

ini

复制代码

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 的依赖注入

Spring Boot的依赖注入（DI）和Golang开源库Wire的依赖注入在设计思路上存在一些相同点和不同点。以下是对这些相同点和不同点的分析：

相同点

降低耦合度：两者都通过依赖注入的方式实现了代码的松耦合。这意味着，一个对象不需要显式地创建或查找它所依赖的其他对象，这些依赖项会由外部容器（如Spring容器）或工具（如Wire）自动提供。
提高可测试性：由于依赖关系被解耦，可以更容易地替换依赖项以进行单元测试。无论是Spring Boot还是使用Wire的Golang应用，都可以轻松地为组件提供模拟或存根的依赖项以进行测试。
灵活性：两者都允许在不修改组件代码的情况下替换依赖项。这使得应用程序在维护和扩展时更加灵活。

不同点

实现方式：
- Spring Boot的依赖注入是基于Java的反射机制和Spring框架的容器管理功能实现的。Spring容器负责创建和管理Bean的生命周期，并在需要时自动注入依赖项，核心在于运行时。
- Wire是一个Golang的代码生成工具，它通过分析代码中的构造函数和结构体标签，自动生成依赖注入的代码（减少人工工作量），在开发阶段已经通过工具生成好了依赖注入的代码，程序编译时，资源之间的依赖关系已经固定。
配置方式：
- Spring Boot的依赖注入通常通过配置文件（如application.properties或application.yml）和注解（如@Autowired）进行配置。开发者可以在配置文件中定义Bean的属性，并通过注解在需要注入的地方指明依赖关系。
- Wire则通过特殊的Go文件（通常是wire.go文件）来定义类型之间的依赖关系。这些文件包含了用于生成依赖注入代码的指令和元数据。
运行时开销：
- Spring Boot的依赖注入在运行时需要依赖Spring容器来管理Bean的生命周期和依赖关系。这可能会引入一些额外的运行时开销，特别是在大型应用程序中。
- Wire在编译时生成依赖注入的代码，因此它在运行时没有额外的开销。这使得使用Wire的Golang应用程序通常具有更好的性能。

历史上的今天

7 月

Golang 依赖注入设计哲学｜12.6K ? 的依赖注入库 wire

一、前言

二、What

2.1 案例分析

三、Why

四、How

4.1 Golang 依赖注入

4.2 针对复杂项目的依赖注入设计哲学

4.3 wire 的更多用法

五、对比 Spring Boot 的依赖注入

相同点

不同点

历史上的今天

用Go+Vue编写自己的轻量工具软件(服务端监控和reids客户端)

推荐一个强大的Go语言工具函数库

go 高并发 TCP 网络编程

PHP转Go系列 | ThinkPHP与Gin框架之OpenApi授权设计实践

全面掌握 Go 语言 errors 标准库：使用指南与源码深度解析

深入理解go map

Node、Python、Go中的websocket

用 go 实现 redis resp 协议解析器

Go 高并发下的锁

使用vscode的SSH插件连接Docker容器进行开发

加载中...

发表评论

热门搜索

一、前言

二、What

2.1 案例分析

三、Why

四、How

4.1 Golang 依赖注入

4.2 针对复杂项目的依赖注入设计哲学

4.3 wire 的更多用法

五、对比 Spring Boot 的依赖注入

相同点

不同点

历史上的今天

发表评论