GoLong的学习之路(番外)如何使用依赖注入工具:wire

我为什么要直接写番外呢?其原因很简单。项目中会使用,其实在这里大家就可以写一些项目来了。

依赖注入的工具本质思想其实都大差不差。无非控制反转和依赖注入。

文章目录

  • 控制反转
    • 为什么需要依赖注入工具
  • wire的概念
    • 提供者(provider)
    • Injector(注入器)
    • `注意`
  • wire的使用
  • 特性
    • 绑定接口
    • 结构体提供者
      • 指针结构体传入的中
        • `注入MyFoo字段`
      • 重要
    • 绑定值
      • 接口值
    • 使用结构的字段作为提供者
    • Cleanup函数

控制反转

控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。

其中最常见的方式叫做依赖注入(Dependency Injection,简称DI)
(还有一种方式通过依赖查找。这个我在我之前的Spring的文章中有写,感兴趣的朋友可以移步)。

依赖注入是生成灵活和松散耦合代码的标准技术,通过明确地向组件提供它们所需要的所有依赖关系。

在 Go 中通常采用将依赖项作为参数传递给构造函数的形式:

构造函数NewBookRepo在创建BookRepo时需要从外部将依赖项db作为参数传入,我们在NewBookRepo中无需关注db的创建逻辑,实现了代码解耦。

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

对于控制反转来说,如果在NewBookPepo 函数中自行创建相关依赖,使得代码的耦合度比较高,并且难以维护和调试。

为了解决这个问题,大佬们就开始想办法,在还华中尽可能的使用控制反转和依赖注入将程序解耦合开,从而写出灵活,并易于测试的程序。

为什么需要依赖注入工具

在小型应用程序中,我们可以自行创建依赖并手动注入。但是在一个大型应用程序中,手动去实现所有依赖的创建和注入就会比较繁琐。

为了方便管理业务,和技术分层,会在实际中划分住不同的代码层。其中MVC就是一个非常常见的业务思想。

例如:
HTTP服务中:
这中模型是最为常见的的模型。
在这里插入图片描述

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

目录: conf/conf.go

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

这里定义了一个默认配置,当然后续可以支持从配置文件或环境变量读取配置信息

在程序的data层,需要定义一个连接数据库的函数,它依赖上面定义的Config并返回一个*gorm.DB(这里使用gorm连接数据库)

目录:data/data.go

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

同时定义一个BookRepo,它有一些数据操作相关的方法。它的构造函数NewBookRepo依赖*gorm.DB,并返回一个*BookRepo

目录:data/data.go

// data/data.gotype BookRepo struct {db *gorm.DB
}func NewBookRepo(db *gorm.DB) *BookRepo {...}

Service层位于data层Server层的中间,它负责实现对外服务。其中构造函数 NewBookService 依赖ConfigBookRepo
目录:service/service.go

// service/service.gotype BookService struct {config *conf.Configrepo   *data.BookRepo
}func NewBookService(cfg *conf.Config, repo *data.BookRepo) *BookService {...}

server层又有一个NewServer构造函数,它依赖外部传入ConfigBookService
目录:server/server.go

// server/server.gotype Server struct {config  *conf.Configservice *service.BookService
}func NewServer(cfg *conf.Config, srv *service.BookService) *Server {...}

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

目录:main.go

// main.gotype Server interface {Run()
}type App struct {server Server
}func newApp(server Server) *App {...}

由于在程序中定义了大量需要依赖注入的构造函数,程序的main函数中会出现以下情形。
目录:main.go

// main.gofunc main() {cfg := conf.NewDefaultConfig()db, _ := data.NewDB(cfg)repo := data.NewBookRepo(db)bookSrv := service.NewBookService(cfg, repo)server := server.NewServer(cfg, bookSrv)app := newApp(server)app.Run()
}

所有依赖的创建和顺序都需要手动维护。

故我们就需要一个工具来解决这个问题。

wire的概念

Go社区中有很多依赖注入框架。比如:Uber的dig和Facebook的inject都使用反射来做运行时依赖注入

Wire 是一个的 Google 开源的依赖注入工具,通过自动生成代码的方式在编译期完成依赖注入。

wire中有两个核心概念:提供者(provider)注入器(injector)

提供者(provider)

提供者函数可以分组为提供者函数集(provider set)。使用wire.NewSet 函数可以将多个提供者函数添加到一个集合中。如果经常同时使用多个提供者函数,这非常有用。

package demoimport (// ..."github.com/google/wire"
)// ...var ProviderSet = wire.NewSet(NewX, NewY, NewZ)

而这个集合也可以作为提供者函数。

package demoimport (// ..."example.com/some/other/pkg"
)
var MegaSet = wire.NewSet(ProviderSet, pkg.OtherSet)

而提供者函数可以实现这几种方式。

  1. 可以产生值的普通函数
type X struct {Value int
}// NewX 返回一个X对象
func NewX() X {return X{Value: 7}
}
  1. 可以使用参数指定依赖项
type Y struct {Value int
}// NewY 返回一个Y对象,需要传入一个X对象作为依赖。
func NewY(x X) Y {return Y{Value: x.Value+1}
}
  1. 可以返回错误的
type Z struct {Value int
}// NewZ 返回一个Z对象,当传入依赖的value为0时会返回错误。
func NewZ(ctx context.Context, y Y) (Z, error) {if y.Value == 0 {return Z{}, errors.New("cannot provide z when value is zero")}return Z{Value: y.Value + 2}, nil
}

Injector(注入器)

应用程序中是用一个注入器来连接提供者,注入器就是一个按照依赖顺序调用提供者。

使用 wire时,你只需要编写注入器的函数签名,然后 wire会生成对应的函数体

要声明一个注入器函数只需要在函数体中调用wire.Build

这个函数的返回值也无关紧要,只要它们的类型正确即可。这些值在生成的代码中将被忽略。

假设上面的提供者函数是在一个名为 wire_demo/demo 的包中定义的,下面将声明一个注入器来得到一个Z函数

package mainimport ("context""github.com/google/wire""wire_demo/demo"
)
func initZ(ctx context.Context) (demo.Z, error) {wire.Build(demo.ProviderSet)return demo.Z{}, nil
}

wire.Build的参数和wire.NewSet一样:都是提供者集合。这些就在该注入器的代码生成期间使用的提供者集。

将上面的代码保存到wire.go中,文件最上面的//go:build wireinject 是必须的(Go 1.18之前的版本使用// +build wireinject),它确保wire.go不会参与最终的项目编译。

注意

在实际运用中我要根据实际业务层,封装不同的wrie的go类,这样方便管理。在哪里调用什么清晰明了

wire的使用

安装wire命令行工具。
命令行:> go install github.com/google/wire/cmd/wire@latest

在wire.go同级目录下执行以下命令: wire

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 !wireinjectpackage mainimport ("context""wire_demo/demo"
)// Injectors from wire.go:func initZ(ctx context.Context) (demo.Z, error) {x := demo.NewX()y := demo.NewY(x)z, err := demo.NewZ(ctx, y)if err != nil {return demo.Z{}, err}return z, nil
}

从生成的内容可以看出,wire生成的内容非常接近开发人员自己编写的内容。

此外,运行时对wire的依赖性很小:所有编写的代码都只是普通的Go代码,可以在没有wire的情况下使用。

特性

绑定接口

依赖项注入通常用于绑定接口的具体实现。

wire通过类型标识将输入与输出匹配,因此倾向于创建一个返回接口类型的提供者。这不是习惯写法,因为Go的最佳实践是返回具体类型。

你可以在提供者集中声明接口绑定:

type Fooer interface {Foo() string
}type MyFooer stringfunc (b *MyFooer) Foo() string {return string(*b)
}func provideMyFooer() *MyFooer {b := new(MyFooer)*b = "Hello, World!"return b
}type Bar stringfunc provideBar(f Fooer) string {// f will be a *MyFooer.return f.Foo()
}var Set = wire.NewSet(provideMyFooer,wire.Bind(new(Fooer), new(*MyFooer)),provideBar,
)

wire.Bind的第一个参数是指向所需接口类型值的指针,第二个参数是指向实现该接口的类型值的指针。任何包含接口绑定的集合还必须具有提供具体类型的提供者。

结构体提供者

可以使用提供的类型构造结构体。

使用wire.Struct函数构造一个结构体类型,并告诉注入器应该注入哪个字段。

注入器将使用字段类型的提供程序填充每个字段。

type Foo int
type Bar intfunc ProvideFoo() Foo {/* ... */}func ProvideBar() Bar {/* ... */}type FooBar struct {MyFoo FooMyBar Bar
}var Set = wire.NewSet(ProvideFoo,ProvideBar,wire.Struct(new(FooBar), "MyFoo", "MyBar"),
)

这个wire会生成一个类似于:

func injectFooBar() FooBar {foo := ProvideFoo()bar := ProvideBar()fooBar := FooBar{MyFoo: foo,MyBar: bar,}return fooBar
}

wire.Struct的第一个参数是指向所需结构体类型的指针,随后的参数是要注入的字段的名称。可以使用一个特殊的字符串“*”作为快捷方式,告诉注入器注入结构体的所有字段。

指针结构体传入的中

对于生成的结构体类型Swire.struct同时提供S*S

注入MyFoo字段
var Set = wire.NewSet(ProvideFoo,wire.Struct(new(FooBar), "MyFoo"),
)

1.生成的类似于:

func injectFooBar() FooBar {foo := ProvideFoo()fooBar := FooBar{MyFoo: foo,}return fooBar
}

2.生成的类似于:

func injectFooBar() *FooBar {foo := ProvideFoo()fooBar := &FooBar{MyFoo: foo,}return fooBar
}

重要

有时防止结构体的某些字段被注入器填充很有必要,尤其是在将*传递给wire.Struct的时候。你可以用wire:"-"标记字段,使wire忽略这些字段。

type Foo struct {mu sync.Mutex `wire:"-"`Bar Bar
}

使用wire.Struct(new(Foo), "*")提供Foo类型时,wire将自动省略mu字段。

此外,在wire.Struct(new(Foo), "mu")中显式指定被忽略的字段也会报错。

绑定值

有时,将基本值(通常为nil)绑定到类型是有用的。

你可以向提供程序集添加一个值表达式,而不是让注入器依赖于一次性提供者函数。

type Foo struct {X int
}func injectFoo() Foo {wire.Build(wire.Value(Foo{X: 42}))return Foo{}
}

生成的注入器:

func injectFoo() Foo {foo := _wireFooValuereturn foo
}var (_wireFooValue = Foo{X: 42}
)

值得注意的是,表达式将被复制到注入器的包中。

对变量的引用将在注入器包的初始化过程中进行计算。如果表达式调用任何函数从任何通道接收任何函数,wire 将会报错。

接口值

对于接口值,使用 InterfaceValue。

func injectReader() io.Reader {wire.Build(wire.InterfaceValue(new(io.Reader), os.Stdin))return nil
}

使用结构的字段作为提供者

用户想要的提供程序是结构的某些字段,如果发现自己在下面的示例中编写了一个类似getS的提供者,可以尝试将结构字段作为所提供的类型:

type Foo struct {S stringN intF float64
}func getS(foo Foo) string {// Bad! Use wire.FieldsOf instead.return foo.S
}func provideFoo() Foo {return Foo{ S: "Hello, World!", N: 1, F: 3.14 }
}func injectedMessage() string {wire.Build(provideFoo,getS,)return ""
}

可以使用wire.FieldsOf直接使用结构体的字段,而无需编写一个类似getS的函数:

func injectedMessage() string {wire.Build(provideFoo,wire.FieldsOf(new(Foo), "S"),)return ""
}

生成为:

func injectedMessage() string {foo := provideFoo()string2 := foo.Sreturn string2
}

可以根据需要将任意多的字段名称添加到wire.FieldsOf中

Cleanup函数

如果提供程序创建了一个需要清理的值(例如关闭文件关闭数据库连接等),那么它可以返回一个闭包来清理资源。

注入器将使用它向调用方返回聚合清理函数,或者在注入器实现中稍后调用的提供程序返回错误时清理资源

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
}

注意
cleanup函数的签名必须是func(),并且保证在提供者的任何输入的cleanup函数之前调用。

总而言之这个番外,还是蛮简单的。

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

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

开放式耳机能保护听力吗?开放式耳机有哪些优缺点?

先说答案,开放式耳机是可以保护听力的! 想要了解开放式耳机是否能保护听力,就要先知道什么是开放式耳机,开放式耳机是一种无需入耳,并且使用时不会堵塞耳道,也不会隔绝外界声音的蓝牙耳机。 一、开放式耳…

Leetcode刷题详解——组合

1. 题目链接:77. 组合 2. 题目描述: 给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1: 输入:n 4, k 2 输出: [[2,4],[3,4],[2,3],[1,2],[1,3],[…

性能测试知多少---了解前端性能

我的上一篇博文中讲到了响应时间,我们在做性能测试时,能过工具可以屏蔽客户端呈现时间,通过局域网的高宽带可以忽略数据传输速度的障碍。这并不是说他们不会对系统造成性能影响。相反,从用户的感受来看,虽然传输速度受…

深度学习_9_图片分类数据集

散装代码: import matplotlib.pyplot as plt import torch import torchvision from torch.utils import data from torchvision import transforms from d2l import torch as d2ld2l.use_svg_display()# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式…

pix2tex - LaTeX OCR 安装使用记录

系列文章目录 文章目录 系列文章目录前言一、安装二、使用三、少侠请留步,点赞、收藏、关注 前言 项目地址:这儿 一、安装 版本要求 Python: 3.7 PyTorch: >1.7.1 安装:pip install "pix2tex[gui]" 注意:Pyside6…

领域认知智能走向落地,B端企业还缺些啥?

大模型如何为我所用? 这是当下B端众多企业都在深入思考的一个问题。今年以来,大模型在办公、对话、搜索等领域所展现出的强大能力,让越来越多B端企业意识到大模型对于业务的巨大价值。 因此,领域认知智能迅速成为B端企业关注的焦…

2-爬虫-代理池搭建、代理池使用(搭建django后端测试)、爬取某视频网站、爬取某视频网站、bs4介绍和遍历文档树

1 代理池搭建 2 代理池使用 2.1 搭建django后端测试 3 爬取某视频网站 4爬取某视频网站 5 bs4介绍和遍历文档树 1 代理池搭建 # ip代理-每个设备都会有自己的IP地址-电脑有ip地址---》访问一个网站---》访问太频繁---》封ip-收费:靠谱稳定--提供api-免费&#xff…

Apache Doris (五十二): Doris Join类型 - Broadcast Join

🏡 个人主页:IT贫道_大数据OLAP体系技术栈,Apache Doris,Clickhouse 技术-CSDN博客 🚩 私聊博主:加入大数据技术讨论群聊,获取更多大数据资料。 🔔 博主个人B栈地址:豹哥教你大数据的个人空间-豹哥教你大数据个人主页-哔哩哔哩视频 目录 1. Broadcast Join原理

freertos多任务

以前我们都是一个任务,假设现在我们创建三个任务,项目工程在上一节网盘 #include "stm32f10x.h" // Device header #include "freertos.h" #include "task.h" #include "usart.h"TaskHandle_t myTaskHan…

Codeforces Round 906 (Div. 2--ABC)

A.Doremys Paint 3 题目 一个元素全为整数的数组,如果满足相邻两个元素和相同,我们就认定此数组is good。给定一个长度为n的数组a,可以任意改变元素顺序,判定数组a是否is good。 输入 首行t测试数据数量, 每组数据…

新一代构建工具Vite-xyphf

一、什么vite? vite:是一款思维比较前卫而且先进的构建工具,他解决了一些webpack解决不了的问题——在开发环境下可以实现按需编译,加快了开发速度。而在生产环境下,它使用Rollup进行打包,提供更好的tree-shaking、代码压缩和性能优化&…

【GEE】基于GEE-Landsat8数据集地表温度反演(LST热度计算)

老样子,最近在做生态方面的项目,然后需要分析城市的热岛效应,想了想还是用GEE计算比较简单,直接下载影像太麻烦了。所以在网上看看了资料,踩了踩坑终于是将代码写出来了。秉承着取之于民、用之于民的想法,今…