经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
来源：cnblogs　　作者：白泽talk　　时间：2024/7/3 14:38:14　　对本文有异议

一、前言

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

本文从“术”层面，讲述“依赖注入”的实现，带你体会其对于整洁架构 & DDD 等设计思想的落地，起到的支撑作用。

涉及内容：

?? B站账号：白泽talk，绝大部分博客内容都将会通过视频讲解，不过文章一般是先于视频发布

image-20240703002016429

白泽的开源 Golang 学习仓库：https://github.com/BaiZe1998/go-learning，用于文章归档 & 聚合博客代码案例

公众号【白泽talk】，本期内容的 pdf 版本，可以关注公众号，回复【依赖注入】获得，往期资源的获取，都是类似的方式。

二、What

?? 本文所涉及编写的代码，已收录于 https://github.com/BaiZe1998/go-learning/di 目录

一句话概括：实例 A 的创建，依赖于实例 B 的创建，且在实例 A 的生命周期内，持有对实例 B 的访问权限。

2.1 案例分析

依赖注入（Dependency Injection, DI），以 Golang 为例，左侧为手动完成依赖注入，右侧为不使用依赖注入：

?? 不使用依赖注入风险：

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

image-20240625222009500

  • 不使用依赖注入 demo
  1. package main
  3. var (
  4. 	mysqlUrl = "mysql://blabla"
  5. 	// 全局数据库实例
  6. 	db = NewMySQLClient(mysqlUrl)
  7. )
  9. func NewMySQLClient(url string) *MySQLClient {
  10. 	return &MySQLClient{url: url}
  11. }
  13. type MySQLClient struct {
  14. 	url string
  15. }
  17. func (c *MySQLClient) Exec(query string, args ...interface{}) string {
  18. 	return "data"
  19. }
  21. func NewApp() *App {
  22. 	return &App{}
  23. }
  25. type App struct {
  26. }
  28. func (a *App) GetData(query string, args ...interface{}) string {
  29. 	data := db.Exec(query, args...)
  30. 	return data
  31. }
  33. // 不使用依赖注入
  34. func main() {
  35. 	app := NewApp()
  36. 	rest := app.GetData("select * from table where id = ?", "1")
  37. 	println(rest)
  38. }
  • 手动依赖注入 demo
  1. package main
  3. func NewMySQLClient(url string) *MySQLClient {
  4. 	return &MySQLClient{url: url}
  5. }
  7. type MySQLClient struct {
  8. 	url string
  9. }
  11. func (c *MySQLClient) Exec(query string, args ...interface{}) string {
  12. 	return "data"
  13. }
  15. func NewApp(client *MySQLClient) *App {
  16. 	return &App{client: client}
  17. }
  19. type App struct {
  20. 	// App 持有唯一的 MySQLClient 实例
  21. 	client *MySQLClient
  22. }
  24. func (a *App) GetData(query string, args ...interface{}) string {
  25. 	data := a.client.Exec(query, args...)
  26. 	return data
  27. }
  29. // 手动依赖注入
  30. func main() {
  31. 	client := NewMySQLClient("mysql://blabla")
  32. 	app := NewApp(client)
  33. 	rest := app.GetData("select * from table where id = ?", "1")
  34. 	println(rest)
  35. }

三、Why

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

四、How

4.1 Golang 依赖注入

以 Golang ?? 最多的开源库 wire 为例讲解：https://github.com/google/wire/blob/main/docs/guide.md

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

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

  • Install：
  1. go install github.com/google/wire/cmd/wire@latest
  • provider: a function that can produce a value

以上面手动实现依赖注入为基础，wire 做的工作是帮助开发者完成如下组装过程

  1. client := NewMySQLClient("mysql://blabla")
  2. app := NewApp(client)

而其中用到的 NewMySQLClient、NewApp 在 wire 定义为一个个的 provider，是需要提前由开发者实现的。

  1. func NewMySQLClient(url string) *MySQLClient {
  2. 	return &MySQLClient{url: url}
  3. }
  5. func NewApp(client *MySQLClient) *App {
  6. 	return &App{client: client}
  7. }

假设系统中的资源很多，配置很多，出现了如下复杂的初始化流程，人工完成依赖注入则变得复杂：

  1. a := NewA(xxx, yyy) error
  2. b := NewB(ctx, a) error
  3. c := NewC(zzz, a, b) error
  4. d := NewD(www, kkk, a) error
  5. e := NewD(ctx, b, d) error
  • injector: a function that calls providers in dependency order

如下是名为 wire.go 的依赖注入配置文件，是一个只会被 wire 命令行工具处理的 injector 文件，用于声明依赖注入流程。

wire.go:

  1. //go:build wireinject
  2. // +build wireinject
  4. // The build tag makes sure the stub is not built in the final build.
  6. package main
  8. import "github.com/google/wire"
  10. // wireApp init application.
  11. func wireApp(url string) *App {
  12. 	wire.Build(NewMySQLClient, NewApp)
  13. 	return nil
  14. }

执行 wire 命令，则在当前目录下生成 wire_gen.go 文件，此时的 wireApp 函数，就等价于最初手动编写的依赖注入流程，可以在真正需要初始化的引入。

wire_gen.go:

  1. // Code generated by Wire. DO NOT EDIT.
  3. //go:generate go run -mod=mod github.com/google/wire/cmd/wire
  4. //go:build !wireinject
  5. // +build !wireinject
  7. package main
  9. // Injectors from wire.go:
  11. // wireApp init application.
  12. func wireApp(url string) *App {
  13.    mySQLClient := NewMySQLClient(url)
  14.    app := NewApp(mySQLClient)
  15.    return app
  16. }

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

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

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

  1. .
  2. ├── biz
  3. │   ├── README.md
  4. │   ├── biz.go
  5. │   └── greeter.go
  6. ├── conf
  7. │   ├── conf.pb.go
  8. │   └── conf.proto
  9. ├── data
  10. │   ├── README.md
  11. │   ├── data.go
  12. │   └── greeter.go
  13. ├── server
  14. │   ├── grpc.go
  15. │   ├── http.go
  16. │   └── server.go
  17. └── service
  18.     ├── README.md
  19.     ├── greeter.go
  20.     └── service.go

各个目录的关系如图：

image-20240702235735708

  • 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 的定义和注入，本质是这样一种状态：

  1. func main() {
  2.     dbClient := NewDBClient()
  3.     dataN := NewDataN(dbClient)
  4.     dataM := NewDataM(dbClient)
  5.     bizA := NewBizA(dataN)
  6.     bizB := NewBizB(dataM)
  7.     bizC := NewBizC(dataN, dataM)
  8.     serviceX := NewService(bizA, bizB, bizC)
  9.     server := NewServer(serviceX)
  10.     server.httpXXX // 提供 http 服务
  11.     server.grpcXXX // 提供 grpc 服务
  12. }

在 helloworld 这个 demo 当中，则是这样定义 provider 的：

  1. // biz 目录
  2. var ProviderSet = wire.NewSet(NewGreeterUsecase)
  4. type GreeterUsecase struct {
  5. 	repo GreeterRepo
  6. 	log  *log.Helper
  7. }
  9. func NewGreeterUsecase(repo GreeterRepo, logger log.Logger) *GreeterUsecase {
  10. 	return &GreeterUsecase{repo: repo, log: log.NewHelper(logger)}
  11. }
  13. func (uc *GreeterUsecase) CreateGreeter(ctx context.Context, g *Greeter) (*Greeter, error) {
  14. 	uc.log.WithContext(ctx).Infof("CreateGreeter: %v", g.Hello)
  15. 	return uc.repo.Save(ctx, g)
  16. }
  18. // data 目录
  19. var ProviderSet = wire.NewSet(NewData, NewGreeterRepo)
  21. type Data struct {
  22. 	// TODO wrapped database client
  23. }
  25. func NewData(c *conf.Data, logger log.Logger) (*Data, func(), error) {
  26. 	cleanup := func() {
  27. 		log.NewHelper(logger).Info("closing the data resources")
  28. 	}
  29. 	return &Data{}, cleanup, nil
  30. }
  32. type greeterRepo struct {
  33. 	data *Data
  34. 	log  *log.Helper
  35. }
  37. func NewGreeterRepo(data *Data, logger log.Logger) biz.GreeterRepo {
  38. 	return &greeterRepo{
  39. 		data: data,
  40. 		log:  log.NewHelper(logger),
  41. 	}
  42. }
  43. // service 目录
  44. var ProviderSet = wire.NewSet(NewGreeterService)
  46. type GreeterService struct {
  47. 	v1.UnimplementedGreeterServer
  49. 	uc *biz.GreeterUsecase
  50. }
  52. func NewGreeterService(uc *biz.GreeterUsecase) *GreeterService {
  53. 	return &GreeterService{uc: uc}
  54. }
  56. func (s *GreeterService) SayHello(ctx context.Context, in *v1.HelloRequest) (*v1.HelloReply, error) {
  57. 	g, err := s.uc.CreateGreeter(ctx, &biz.Greeter{Hello: in.Name})
  58. 	if err != nil {
  59. 		return nil, err
  60. 	}
  61. 	return &v1.HelloReply{Message: "Hello " + g.Hello}, nil
  62. }
  64. // server 目录
  65. var ProviderSet = wire.NewSet(NewGRPCServer, NewHTTPServer)
  67. func NewGRPCServer(c *conf.Server, greeter *service.GreeterService, logger log.Logger) *grpc.Server {
  68. 	var opts = []grpc.ServerOption{
  69. 		grpc.Middleware(
  70. 			recovery.Recovery(),
  71. 		),
  72. 	}
  73. 	if c.Grpc.Network != "" {
  74. 		opts = append(opts, grpc.Network(c.Grpc.Network))
  75. 	}
  76. 	if c.Grpc.Addr != "" {
  77. 		opts = append(opts, grpc.Address(c.Grpc.Addr))
  78. 	}
  79. 	if c.Grpc.Timeout != nil {
  80. 		opts = append(opts, grpc.Timeout(c.Grpc.Timeout.AsDuration()))
  81. 	}
  82. 	srv := grpc.NewServer(opts...)
  83. 	v1.RegisterGreeterServer(srv, greeter)
  84. 	return srv
  85. }

在 helloworld 这个 demo 当中，则是这样定义 injector 的：

  1. // wire.go
  2. func wireApp(*conf.Server, *conf.Data, log.Logger) (*kratos.App, func(), error) {
  3.    panic(wire.Build(server.ProviderSet, data.ProviderSet, biz.ProviderSet, service.ProviderSet, newApp))
  4. }

最后运行 wire 的到的完成注入的文件如下：

  1. // wire_gen.go
  2. func wireApp(confServer *conf.Server, confData *conf.Data, logger log.Logger) (*kratos.App, func(), error) {
  3. 	dataData, cleanup, err := data.NewData(confData, logger)
  4. 	if err != nil {
  5. 		return nil, nil, err
  6. 	}
  7. 	greeterRepo := data.NewGreeterRepo(dataData, logger)
  8. 	greeterUsecase := biz.NewGreeterUsecase(greeterRepo, logger)
  9. 	greeterService := service.NewGreeterService(greeterUsecase)
  10. 	grpcServer := server.NewGRPCServer(confServer, greeterService, logger)
  11. 	httpServer := server.NewHTTPServer(confServer, greeterService, logger)
  12. 	app := newApp(logger, grpcServer, httpServer)
  13. 	return app, func() {
  14. 		cleanup()
  15. 	}, nil
  16. }

生成代码之后，则可以像使用普通的 golang 函数一样，使用这个 wire_gen.go 文件内的 wireApp 函数实例化一个 helloworld 服务

  1. func main() {
  2. 	flag.Parse()
  3. 	logger := log.With(log.NewStdLogger(os.Stdout),
  4. 		// ...
  5. 	)
  6. 	c := config.New(
  7.         // ...
  8. 	)
  9. 	defer c.Close()
  10. 	// ...
  12. 	app, cleanup, err := wireApp(bc.Server, bc.Data, logger)
  13. 	if err != nil {
  14. 		panic(err)
  15. 	}
  16. 	defer cleanup()
  18. 	// start and wait for stop signal
  19. 	if err := app.Run(); err != nil {
  20. 		panic(err)
  21. 	}
  22. }

4.3 wire 的更多用法

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

  • 定义携带 error 返回值的 provider
  1. func ProvideBaz(ctx context.Context, bar Bar) (Baz, error) {
  2.     if bar.X == 0 {
  3.         return Baz{}, errors.New("cannot provide baz when bar is zero")
  4.     }
  5.     return Baz{X: bar.X}, nil
  6. }
  • provider 集合：方便组织多个 provider
  1. var SuperSet = wire.NewSet(ProvideFoo, ProvideBar, ProvideBaz)
  • 接口绑定：
  1. type Fooer interface {
  2.     Foo() string
  3. }
  5. type MyFooer string
  7. func (b *MyFooer) Foo() string {
  8.     return string(*b)
  9. }
  11. func provideMyFooer() *MyFooer {
  12.     b := new(MyFooer)
  13.     *b = "Hello, World!"
  14.     return b
  15. }
  17. type Bar string
  19. func provideBar(f Fooer) string {
  20.     // f will be a *MyFooer.
  21.     return f.Foo()
  22. }
  24. var Set = wire.NewSet(
  25.     provideMyFooer,
  26.     wire.Bind(new(Fooer), new(*MyFooer)),
  27.     provideBar)

五、对比 Spring Boot 的依赖注入

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

相同点

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

不同点

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

六、参考资料

kratos：https://go-kratos.dev/en/docs/getting-started/start/

wire：https://github.com/google/wire/blob/main/_tutorial/README.md

原文链接：https://www.cnblogs.com/YLTFY1998/p/18280945

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号