阿坝州网站建设公司

golang常用库包：Go依赖注入(DI)工具-wire使用

google 出品的依赖注入库 wire：https://github.com/google/wire

为武都等地区用户提供了全套网页设计制作服务，及武都网站建设行业解决方案。主营业务为网站设计制作、成都网站建设、武都网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

什么是依赖注入

依赖注入 ，英文全名是 dependency injection，简写为 DI。

百科解释：

依赖注入是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。

在用编程语言编写程序时，比如用 java 语言，会编写很多类，这些类之间相互调用，完成一个具体的功能。

例如，从 MySQL 获取数据，那么需要一个 MySQL 操作类 。

第一次编写mysql操作类：

class MySQL{
}

要从 mysql 获取数据，那么 mysql 数据库的用户名，密码，地址等等这些配置信息，也是需要的，继续编写 MySQL 类：

package com.demo.mysql

class MySQL {
    getMySQLConfig() {
        port = 3306;
        username = "xxx";
        password = "xxx";
    }
    
    initMySQL(){}
   
    querySQL(){}
}

进一步思考，上面的 MySQL 操作类程序有什么不妥的地方？

编程原则里有一个原则就是：单一职责

也就是说一个类最好只干一件事情。

根据这个原则在看看 MySQL 类，里面有获取数据库配置数据，也有操作MySQL的方法，不是单一职责的。
那里面获取数据库配置数据，可不可以单独拎出来用一个类表示？ 当然可以。

因为 MySQL 配置数据，多数是从文件里读取的，上面 MySQL 类是写死，这也是不合理的一个地方。
而配置文件的来源，可以是 yml 格式文件，也可以是 toml 格式文件，还可以是远程文件。

第二次编写mysql操作类：

修改上面的类，增加一个获取数据库配置的类：

package com.demo.mysql

class MySQLConfig {
      getMySQLConfig() {
        // 从配置文件获取 mysql 配置数据
    }
}

获取数据的类变成：

package com.demo.mysql

class MySQL {
    initMySQL(){
     // 获取数据库的配置信息
     mysqlconfig = new MySQLConfig();
    }
   
    querySQL(){}
}

思考一下，上面改写后的类有什么不妥的地方？
获取mysql的配置信息，是不是要在 MySQL 类里 new一下， 实例化一下，如果不在同一个包下，还要把配置类引入进来在才能实例化。这里能不能优化下，当然可以。

直接把数据库配置类注入到 MySQL 操作类里。这就是依赖注入。

  • 依赖是什么？注入又是什么？
    mysql 操作类依赖谁？依赖数据库配置类。
    注入什么？把数据库配置类注入到 mysql 操作类里。
    注入是一个动作，把一个类注入到另外一个类。
    依赖是一种关系，类关系，一个类要完全发挥作用，需要依赖另外一个类。

要完成数据操作，mysql操作类是需要依赖数据库配置类的，把数据库配置类注入到mysql操作类里，就可以完成操作类功能。

第三次编写mysql操作类：

伪代码示例：

package com.demo.mysql

class MySQL {
    private MySQLConfig config
    MySQL(MySQLConfig mysqlconfig) { // 数据库配置类这里注入到mysql操作类里
        config = mysqlconfig
    }
    initMySQL(){
    
    }
   
    querySQL(){}
}

把数据库配置类注入到mysql操作类里。

写 java 的人都知道 java 框架里有一个 spring 全家桶，spring 框架包核心有2个，其中有一个核心就是 IoC，另一个是 aop。

IoC 的全称：Inversion of Control，控制反转。

这个控制反转也是面向对象编程原则之一。

但是这个控制反转比较难理解，如果结合上面的 DI 来理解，就比较容易理解点。
可以把 DI 看作是 IoC 编程原则的一个具体实现。

依赖注入还可以从另外的软件设计思想来理解：

  1. 分离关注点
  2. 高内聚，低耦合

对数据库 mysql 的操作和 mysql 的配置信息，这个 2 个是可以相互独立，相分离的。

何时使用依赖注入

当你的项目规模不大，文件不是很多，一个文件调用只需要传入少量依赖对象时，这时使用依赖注入就会使程序变得繁琐。

当规模变大，单个对象使用需要调用多个依赖对象时，而这些依赖又有自己依赖对象，这时对象创建变得繁琐，那么这时候依赖注入就可以出场了。

wire 概念说明

wire 简介

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

与其他依赖注入工具不同，比如 uber 的 dig 和 facebook 的 inject，这 2 个工具都是使用反射实现的依赖注入，而且是运行时注入（runtime dependency injection）。

wire 是编译代码时生成代码的依赖注入，是编译期间注入依赖代码（compile-time dependency injection）。而且代码生成期间，如果依赖注入有问题，生成依赖代码时就会出错，就可以报出问题来，而不必等到代码运行时才暴露出问题。

provider 和 injector

首先，需要理解 wire 的 2 个核心概念：provider 和 injector。

从上面 java 模拟依赖注入的例子中，可以简化出依赖注入的步骤：

第一：需要 New 出一个类实例
第二：把这个 New 出来的类实例通过构造函数或者其他方式“注入”到需要使用它的类中
第三：在类中使用这个 New 出来的实例

从上面步骤来理解 wire 的 2 个核心概念 provider 和 injector。

provider 就相当于上面 New 出来的类实例。
injector 就相当于“注入”动作前，把所需依赖函数进行聚合，根据这个聚合的函数生成依赖关系。

provider：提供一个对象。
injector：负责根据对象依赖关系，生成新程序。

provider

provider 是一个普通的 Go 函数 ，可以理解为是一个对象的构造函数。为下面生成 injector 函数提供”构件“。

看下面例子，来自 go blog。

这篇 blog 是 2018.10.9 发表，可能一些信息有点老，再参考 github guide ，这篇 guide 最后更新于 2021.1.26。

下面的 NewUserStore() 函数可以看作是一个 provider。这个函数需要传入 *Config 和 *mysql.DB 2 个参数。

// NewUserStore 是一个 provider for *UserStore，*UserStore 依赖 *Config，*mysql.DB
func NewUserStore(cfg *Config, db *mysql.DB) (*UserStore, error) {... ...}

// NewDefaultConfig 是一个 provider for *Config，没有任何依赖
func NewDefaultConfig() *Config {...}

// NewDB 是 *mysql.DB 的一个 provider ，依赖于数据库连接信息 *ConnectionInfo
func NewDB(info *ConnectionInfo) (*mysql.DB, error){...}

provider 可以组合成一组 provider set。对于经常在一起使用的 providers 来说，这个非常有用。使用 wire.NewSet 方法可以把他们组合在一起，

var SuperSet = wire.NewSet(NewUserStore, NewDefaultConfig)

你也可以把其他的 provider sets 加入一个 provider set，

import （
    “example.com/some/other/pkg”
）

// ... ...
var MegaSet = wire.NewSet(SuperSet, pkg.OtherSet)

wire.NewSet() 函数：

这个函数可以把相关的 provider 组合在一起然后使用。当然也可以单独使用，如 var Provider = wire.NewSet(NewDB)。

这个 NewSet 函数的返回值也可以作为其他 NewSet 函数的参数使用，比如上面的 SuperSet 作为参数使用。

injector

我们编写程序把这些 providers 组合起来(比如下面例子 initUserStore() 函数)，wire 里的 wire 命令会按照依赖顺序调用 providers 生成更加完整的函数，这个就是 injector。

首先，编写生成 injector 的签名函数，然后用 wire 命令生成相应的函数。

例子如下：

// +build wireinject

func initUserStore(info *ConnectionInfo) (*UserStore, error) {
    wire.Build(SuperSet, NewDB) // 声明获取 UserStore 需要调用哪些 provider 函数
    return nil, nil
}

然后用 wire 命令把上面的 initUserStore 函数生成 injector 函数，生成的函数对应文件名 wire_gen.go。

wire 命令:

You can generate the injector by invoking Wire in the package directory。

直接在生成 injector 函数的包下，使用 wire 命令，就可以生成 injector 代码。

wire.Build() 函数：

它的参数可以是 wire.NewSet() 组织的一个或多个 provider，也可以直接使用 provider。

wire 使用

wire 结构体和方法列表

func Build(...interface{}) string
type Binding
	func Bind(iface, to interface{}) Binding
type ProvidedValue
	func InterfaceValue(typ interface{}, x interface{}) ProvidedValue
	func Value(interface{}) ProvidedValue
type ProviderSet
	func NewSet(...interface{}) ProviderSet
type StructFields
	func FieldsOf(structType interface{}, fieldNames ...string) StructFields
type StructProvider
	func Struct(structType interface{}, fieldNames ...string) StructProvider

更详细说明可以看这里 func index - pkg.go.dev。

wire 安装

go get github.com/google/wire/cmd/wire

快速开始

例子1

先新建一个 basics 的文件夹，然后在 basics 里使用 go mod init basics，新建一个 go.mod，在 go.mod 里引入 wire：require github.com/google/wire v0.5.0。

整个文件夹目录结构:

  1. 定义 providers

在 basics 文件夹下新建 basics.go 文件，写入如下代码：

package main

import (
	"context"
	"errors"
)

type Student struct {
	ClassNo int
}

// NewStudent 就是一个 provider，返回一个 Student
func NewStudent() Student {
	return Student{ClassNo: 10}
}

type Class struct {
	ClassNo int
}

// NewClass 就是一个 provider，返回一个 Class
func NewClass(stu Student) Class {
	return Class{ClassNo: stu.ClassNo}
}

type School struct {
	ClassNo int
}

// NewSchool 是一个 provider，返回一个 School
// 与上面 provider 不同的是，它还返回了一个错误信息
func NewSchool(ctx context.Context, class Class) (School, error) {
	if class.ClassNo == 0 {
		return School{}, errors.New("cannot provider school when class is 0")
	}
	return School{ClassNo: class.ClassNo}, nil
}
  1. 定义 injector

新建文件 wire.go，代码如下：

// +build wireinject

package main

import (
	"github.com/google/wire"
)

var SuperSet = wire.NewSet(NewStudent, NewClass, NewSchool)

func initSchool() (School, error) {
	wire.Build(SuperSet)
	return School{}, nil
}

// +build wireinject

这一行代码一定要在包最上面声明，表明这是一个准备被编译的 injector

  1. 用 wire 命令生成 injector 函数代码

用 wire 命令生成 injector 代码，在 basics 目录下执行 wire 命令：

$ wire
wire: D:\work\mygo\go-practice2\di\wire\basics\wire.go:9:1: inject initSchool: no provider found for context.Context needed by basics.School in provider set "SuperSet" (D:\work\mygo\go-practice2\di\wire\basics\wire.go:7:16)

wire: basics: generate failed
wire: at least one generate failure

报错了，看看显示出的错误信息，最主要是这一行信息：

inject initSchool: no provider found for context.Context needed by basics.School in provider set "SuperSet"

来看一看 initSchool 函数，果然没有给它提供 context.Context 。我们来修改函数，引入 context 包，然后给 initSchool 函数增加参数 context.Context：

func initSchool(ctx context.Context) (School, error) {
	wire.Build(SuperSet)
	return School{}, nil
}

再来用命令 wire 编译：

$ wire
wire: basics: wrote D:\work\mygo\go-practice2\di\wire\basics\wire_gen.go

生成的 injector 代码，wire_gen.go 文件，

// Code generated by Wire. DO NOT EDIT.

//go:generate go run github.com/google/wire/cmd/wire
//+build !wireinject

package main

import (
	"context"
	"github.com/google/wire"
)

// Injectors from wire.go:

func initSchool(ctx context.Context) (School, error) {
	student := NewStudent()
	class := NewClass(student)
	school, err := NewSchool(ctx, class)
	if err != nil {
		return School{}, err
	}
	return school, nil
}

// wire.go:

var SuperSet = wire.NewSet(NewStudent, NewClass, NewSchool)

小结

wire 使用的步骤：

  1. 先编写 provider。
  2. 再编写 injector：把相关 provider 组织在一起，成为一个 ProviderSet。
  3. 最后用 wire 命令编译：wire 会根据 provider 之间相关依赖生成代码。

wire.NewSet 函数：

它可以把 provider 集合起来。作用1分类：可以把一组相关的 provider 写在一起组成 ProviderSet。作用1延伸第2个作用，避免 provider 过多难于管理。

wite.Build 函数：

func Build(...interface{}) string

它的参数是 provider 不定长列表。 把所有相关的 provider 组织在一起然后生成 injector 函数代码。它是生成 injector 函数的模板函数。

绑定接口

上面例子1绑定的是结构体和构造函数。如果有接口 interface 参与呢，那怎么办？比如下面的代码，

type Fooer interface {
    Hello()
}

type Foo struct{}

func (f Foo)Hello() {
    fmt.Println("hello")
}

func Bar struct{}

func NewBar() Bar {
    return Bar{}
}

有接口 Fooer，这个怎么绑定呢？这时候就可以用 [wire.Bind](wire/wire.go at v0.5.0 · google/wire · GitHub) 函数，

var bind = wire.Bind(new(Fooer), new(Foo))
var set = wire.NewSet(bind, NewBar)

// or
var set = wire.NewSet(wire.Bind(new(Fooer), new(Foo)), NewBar)

struct prividers

struct 也可以直接当作一个 provider 使用。如果结构体的 provider 仅仅是用作字段赋值，那么可以使用函数 wire.Struct 来赋值。

type Foo int
type Bar int

func NewFoo() Foo {/* ... */}
func NewBar() Bar {/* ... */}

type FooBar struct {
    MyFoo Foo
    MyBar Bar
}

var set = wire.NewSet(
	NewFoo,
    NewBar,
    wire.Struct(new(FooBar), "MyFoo", "MyBar"),
)

更多信息请参考struct providers guide

Provider Set

上面例子1中就用到 provider set，把

相关的 provider 组织在一起。使用函数 wire.NewSet 就可以做到。

更多例子请查看官方文档：

https://github.com/google/wire

参考

  • https://github.com/google/wire
  • https://github.com/google/wire/blob/main/docs/guide.md
  • https://go.dev/blog/wire
  • wire func index - pkg

当前标题：golang常用库包：Go依赖注入(DI)工具-wire使用
文章路径：http://azwzsj.com/article/dsoisso.html

其他资讯