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

news2024/10/6 6:52:29

一、前言

线上项目往往依赖非常多的具备特定能力的资源，如：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，绝大部分博客内容都将会通过视频讲解，不过文章一般是先于视频发布

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
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 为例讲解：https://github.com/google/wire/blob/main/docs/guide.md

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

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

  • Install：
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 目录的内容：

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

各个目录的关系如图：

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

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
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的依赖注入在设计思路上存在一些相同点和不同点。以下是对这些相同点和不同点的分析：

相同点
  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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1892480.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

游戏AI的创造思路-技术基础-自然语言处理

游戏AI的创造思路-技术基础-自然语言处理

自然语言处理-可以对游戏AI特别是RPG类、语言类游戏进行“附魔”，开发出“随机应变”和你聊天的“女友”、“队友”或者是根据你定义的文本库来用接近自然语言的生成“语言”，推动游戏情景在受控范围内前进 目录 1. 自然语言处理定义 2. 发展历史 3. …
阅读更多...
【配置网络和使用ssh服务】

【配置网络和使用ssh服务】

文章目录 一、配置文件二、配置网络1.使用系统菜单配置网络2.通过网卡配置文件配置网络3.使用图形界面配置网络4.使用nmcli命令配置网络 三、配置远程控制服务1.配置sshd服务2.安全密钥验证3.远程传输命令 一、配置文件 跟网络有关的主要配置文件如下： /etc/host.c…
阅读更多...
RS232、RS485、RS422、RS423、RS449的联系与区别

RS232、RS485、RS422、RS423、RS449的联系与区别

这些标准（RS232、RS485、RS422、RS423、RS449）都涉及将并行数据转换为串行数据进行传输： 数据转换过程： 在发送端，并行数据（通常是字节或字）被转换成串行比特流。 在接收端，串行比特…
阅读更多...
CH552G使用的pwm出现的问题，及设置

CH552G使用的pwm出现的问题，及设置

输出pwm的频率周期很不准确 可能是因为没有外部晶振的稳定晶振周期有关。 使用的示波器出现操作失误 在使用小型示波器的过程中发现集成了信号发生器和示波器的连接端口是不同的。刚开始把示波器测试口错插入了信号发生器的接口，困扰好一会儿，幸好用一…
阅读更多...
Zabbix 配置WEB监控

Zabbix 配置WEB监控

Zabbix WEB监控介绍 在Zabbix中配置Web监控，可以监控网站的可用性和响应时间。Zabbix提供了内置的Web监控功能，通过配置Web场景（Web Scenario），可以监控HTTP/HTTPS协议下的Web服务。 通过Zabbix的WEB监控可以监控网站…
阅读更多...
超声波气象站的工作原理

超声波气象站的工作原理

TH-CQX5超声波气象站中的超声波技术是其核心工作原理之一，以下是关于超声波气象站中超声波的详细解释：超声波是一种频率高于人耳能听到的声音频率范围的声波，通常指频率在20kHz以上的声波。超声波具有较短的波长和强的穿透能力，能…
阅读更多...
vue安装+测试

vue安装+测试

1.下载node.js 在浏览器中打开nodejs官网https://nodejs.org/zh-cn/ ，选择需要的版本 2.检查nodejs是否安装成功 打开cmd，输入命令 node -v PS C:\Users\neuer> node -v v20.15.03.安装cnpm 遇到npm ERR! code CERT_HAS_EXPIRED问题 清除npm缓存 n…
阅读更多...
【TS】交叉类型 和 联合类型

【TS】交叉类型 和 联合类型

文章目录 1. 交叉类型（Intersection Types）2. 联合类型（Union Types） 1. 交叉类型（Intersection Types） 交叉类型将多个类型合并为一个类型，这个新类型具有所有类型的特性。使用 & 符号来定…
阅读更多...
妙手ERP接入Miravia，支持高效上货、批量订单处理

妙手ERP接入Miravia，支持高效上货、批量订单处理

欧洲电子商务市场目前已经成为了中国跨境电商出口的“新蓝海”。放眼欧洲，西班牙电商市场规模并不算大，但却是增长率最高的市场之一，并且正在追赶其他电商市场。　 据Statista的调查数据显示，2024年初西班牙的电商收入将达到355亿…
阅读更多...
python自动化办公-往ppt插入图片

python自动化办公-往ppt插入图片

目录 思路 代码 代码效果 思路 1、导包 2、打开ppt 3、新增1张幻灯片，选择自己需要的版式 4、输入标题 5、设置好图片的位置和大小，插入准备好的图片 6、保存文件 代码 from pptx import Presentation from pptx.util import Inches # 打开pp…
阅读更多...
【C语言入门】初识C语言：掌握编程的基石

【C语言入门】初识C语言：掌握编程的基石

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C语言 “ 登神长阶 ” 🤡往期回顾🤡：C语言入门 🌹🌹期待您的关注 🌹🌹 ❀C语言入门 📒1. 选择…
阅读更多...
c-＞c++(二):class

c-＞c++(二):class

本文主要探讨C类的相关知识。 构造和析构函数 构造函数(可多个)：对象产生时调用初始化class属性、分配class内部需要的动态内存 析构函数（一个）：对对象消亡时调用回收分配动态内存 C提供默认构造和析构,…
阅读更多...
使用pdf.js在Vue、React中预览Pdf文件,支持PC端、移动端

使用pdf.js在Vue、React中预览Pdf文件,支持PC端、移动端

📝 使用背景 在前端开发中，有时候我们需要进行pdf文件的预览操作，通过在网上查询，基本都是一下几种常见的预览pdf文件的方法： 实现方案效果HTML 标签iframe 标签iOS：只能展示第一页，多页不能展…
阅读更多...
Windows安全认证机制——Windows常见协议

Windows安全认证机制——Windows常见协议

一.LLMNR协议 1.LLMNR简介 链路本地多播名称解析（LLMNR）是一个基于域名系统（DNS）数据包格式的协议，使用此协议可以解析局域网中本地链路上的主机名称。它可以很好地支持IPv4和IPv6，是仅次于DNS解析的名称…
阅读更多...
63、基于深度学习网络的数字分类(matlab)

63、基于深度学习网络的数字分类(matlab)

1、基于深度学习网络的数字分类的原理及流程 基于深度学习网络的数字分类是一种常见的机器学习任务，通常使用的是卷积神经网络（CNN）来实现。下面是其原理及流程的简要说明： 数据收集：首先，需要收集包含数字…
阅读更多...
Mybatis一级缓存

Mybatis一级缓存

缓存 MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。 Mybatis和Hibernate一样，也有一级和二级缓存，同样默认开启的只有一级缓存，二级缓…
阅读更多...
【笔记】解决 CSS：backface-visibility:hidden； 容器翻转 引起的容器内 input不可用

【笔记】解决 CSS：backface-visibility:hidden； 容器翻转 引起的容器内 input不可用

起因 今天，做了一个卡片翻转的案例。原本参考的案例是一个非常简单的两个div翻面效果，使用的 backface-visibility:hidden; 实现两个容器互为背面。基础div就是纯色，什么都没有，很容易就实现了翻转。 出现问题 我要做的案例&am…
阅读更多...
【Python机器学习】算法链与管道——在网格搜索中使用管道

【Python机器学习】算法链与管道——在网格搜索中使用管道

在网格搜索中使用管道的工作原理与使用任何其他估计器都相同。 我们定义一个需要搜索的参数网络，并利用管道和参数网格构建一个GridSearchCV。不过在指定参数网格时存在一处细微的变化。我们需要为每个参数指定它在管道中所属的步骤。我们要调节的两个参数C和gamma…
阅读更多...
NGINX+KEEPALIVED | 一文搞懂NG+KL负载均衡高可用架构的实操教程（详细）

NGINX+KEEPALIVED | 一文搞懂NG+KL负载均衡高可用架构的实操教程（详细）

文章目录 NGINXKEEPALIVED负载均衡高可用架构为什么需要多节点应用为什么需要Nginx服务为什么需要Keepalived服务NGKL简述前期准备Linux服务器公共环境配置Server1 NGKL服务器配置Server2 NGKL服务器配置Server3 HTTP服务器配置Server4 HTTP服务器配置运行测试用例 NGINXKEEPAL…
阅读更多...
Android选择题界面的设计——线性布局实操

Android选择题界面的设计——线性布局实操

目录 任务目标任务分析任务实施 任务目标 使用TextView、Button、CheckBox等实现一个选择题界面，界面如图1所示。 图1 选择题界面效果图 任务分析 上述界面可以分解为上下两部分，上面部分可以使用横向的线性布局来完成，下面部分可以使用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023