关于golang:golang依赖注入工具wire指南

wire与依赖注入

Wire 是一个的Golang依赖注入工具，通过主动生成代码的形式在编译期实现依赖注入，Java体系中最闻名的Spring框架采纳运行时注入，集体认为这是wire和其余依赖注入最大的不同之处。

依赖注入(Dependency Injection)也称作管制反转(Inversion of Control)，集体给管制反转下的定义如下：

以后对象须要的依赖对象由内部提供（通常是IoC容器），内部负责依赖对象的结构等操作，以后对象只负责调用，而不关怀依赖对象的结构。即依赖对象的控制权交给了IoC容器。

上面给出一个管制反转的示例，比方咱们通过配置去创立一个数据库连贯：

// 连贯配置
type DatabaseConfig struct {
    Dsn string 
}

func NewDB(config *DatabaseConfig)(*sql.DB, error) {
    db,err := sql.Open("mysql", config.Dsn)
    if err != nil {
        return nil, err
    }
    // ...
}

fun NewConfig()(*DatabaseConfig,error) {
    // 读取配置文件
    fp, err := os.Open("config.json")
    if err != nil {
        return nil,err
    }
    defer fp.Close()
    // 解析为Json
    var config DatabaseConfig
    if err:=json.NewDecoder(fp).Decode(&config);err!=nil {
        return nil,err
    }
    return &config, nil
}

func InitDatabase() {
    cfg, err:=NewConfig()
    if err!=nil {
        log.Fatal(err)
    }
    db,err:=NewDB(cfg)
    if err!=nil {
        log.Fatail(err)
    }
    // db对象结构结束
}

NewDBNewConfigNewDBNewDB

来看一个背面例子，也就是管制正转：

以后对象须要的依赖由本人创立，即依赖对象的控制权在以后对象本人手里。

type DatabaseConfig struct {
    Dsn string 
}

func NewDB()(*sql.DB, error) {
    // 读取配置文件
    fp, err := os.Open("config.json")
    if err != nil {
        return nil,err
    }
    defer fp.Close()
    // 解析为Json
    var config DatabaseConfig
    if err:=json.NewDecoder(fp).Decode(&config);err!=nil {
        return nil,err
    }
    // 初始化数据库连贯
    db,err = sql.Open("mysql", config.Dsn)
    if err != nil {
        return
    }
    // ...
}

NewDBNewDB

依赖注入诚然好用，然而像方才的例子中去手动治理依赖关系是相当简单也是相当苦楚的一件事，因而在接下来的内容中会重点介绍golang的依赖注入工具——wire。

上手应用

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

ProviderInjector

Provider管制反转示例NewDBNewConfigInjector管制反转示例InitDatabase

wire

|--cmd
    |--main.go
    |--wire.go
|--config
    |--app.json
|--internal
    |--config
        |--config.go
    |--db
        |--db.go

config/app.json

{
  "database": {
    "dsn": "root:root@tcp(localhost:3306)/test"
  }
}

internal/config/config.go

package config

import (
    "encoding/json"
    "github.com/google/wire"
    "os"
)

var Provider = wire.NewSet(New) // 将New办法申明为Provider，示意New办法能够创立一个被他人依赖的对象,也就是Config对象

type Config struct {
    Database database `json:"database"`
}

type database struct {
    Dsn string `json:"dsn"`
}

func New() (*Config, error) {
    fp, err := os.Open("config/app.json")
    if err != nil {
        return nil, err
    }
    defer fp.Close()
    var cfg Config
    if err := json.NewDecoder(fp).Decode(&cfg); err != nil {
        return nil, err
    }
    return &cfg, nil
}

internal/db/db.go

package db

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "github.com/google/wire"
    "wire-example2/internal/config"
)

var Provider = wire.NewSet(New) // 同理

func New(cfg *config.Config) (db *sql.DB, err error) {
    db, err = sql.Open("mysql", cfg.Database.Dsn)
    if err != nil {
        return
    }
    if err = db.Ping(); err != nil {
        return
    }
    return db, nil
}

cmd/main.go

package main

import (
    "database/sql"
    "log"
)

type App struct { // 最终须要的对象
    db *sql.DB
}

func NewApp(db *sql.DB) *App {
    return &App{db: db}
}

func main() {
    app, err := InitApp() // 应用wire生成的injector办法获取app对象
    if err != nil {
        log.Fatal(err)
    }
    var version string
    row := app.db.QueryRow("SELECT VERSION()")
    if err := row.Scan(&version); err != nil {
        log.Fatal(err)
    }
    log.Println(version)
}

cmd/wire.go

重点文件，也就是实现Injector的外围所在：

// +build wireinject

package main

import (
    "github.com/google/wire"
    "wire-example2/internal/config"
    "wire-example2/internal/db"
)

func InitApp() (*App, error) {
    panic(wire.Build(config.Provider, db.Provider, NewApp)) // 调用wire.Build办法传入所有的依赖对象以及构建最终对象的函数失去指标对象
}

cmdwire

C:\Users\Administrator\GolandProjects\wire-example2\cmd>wire
wire: wire-example2/cmd: wrote C:\Users\Administrator\GolandProjects\wire-example2\cmd\wire_gen.go

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 (
    "wire-example2/internal/config"
    "wire-example2/internal/db"
)

// Injectors from wire.go:

func InitApp() (*App, error) {
    configConfig, err := config.New()
    if err != nil {
        return nil, err
    }
    sqlDB, err := db.New(configConfig)
    if err != nil {
        return nil, err
    }
    app := NewApp(sqlDB)
    return app, nil
}

能够看到生成App对象的代码曾经主动生成了。

Provider阐明

NewSetProviderNewSetdb

var Provider = wire.NewSet(NewDB, NewRedis)

func NewDB(config *Config)(*sql.DB,error) { // 创立数据库对象
    
}

func NewRedis(config *Config)(*redis.Client,error) { // 创立Redis对象
}

wire.go文件阐明

wire.goConfigDBAppwire.goApp

wire.go文件名不是固定的，不过大家习惯叫这个文件名。

wire.go// +build wireinject

只有增加了名称为”wireinject”的build tag，本文件才会编译，而咱们go build main.go的时候通常不会加。因而，该文件不会参加最终编译。

wire.Build(config.Provider, db.Provider, NewApp)configdbApp

wire_gen.go文件阐明

wire

//+build !wireinjectwire.go

编译时只有未增加“wireinject”的build tag，本文件才参加编译。

wire.gowire_gen.go

高级玩法

cleanup函数

db.Newcleanup

internal/db/db.go

func New(cfg *config.Config) (db *sql.DB, cleanup func(), err error) { // 申明第二个返回值
    db, err = sql.Open("mysql", cfg.Database.Dsn)
    if err != nil {
        return
    }
    if err = db.Ping(); err != nil {
        return
    }
    cleanup = func() { // cleanup函数中敞开数据库连贯
        db.Close()
    }
    return db, cleanup, nil
}

cmd/wire.go

func InitApp() (*App, func(), error) { // 申明第二个返回值
    panic(wire.Build(config.Provider, db.Provider, NewApp))
}

cmd/main.go

func main() {
    app, cleanup, err := InitApp() // 增加第二个参数
    if err != nil {
        log.Fatal(err)
    }
    defer cleanup() // 提早调用cleanup敞开资源
    var version string
    row := app.db.QueryRow("SELECT VERSION()")
    if err := row.Scan(&version); err != nil {
        log.Fatal(err)
    }
    log.Println(version)
}

wirewire_gen.go

func InitApp() (*App, func(), error) {
    configConfig, err := config.New()
    if err != nil {
        return nil, nil, err
    }
    sqlDB, cleanup, err := db.New(configConfig)
    if err != nil {
        return nil, nil, err
    }
    app := NewApp(sqlDB)
    return app, func() { // 返回了清理函数
        cleanup()
    }, nil
}

接口绑定

在面向接口编程中，代码依赖的往往是接口，而不是具体的struct，此时依赖注入相干代码须要做一点小小的批改，持续方才的例子，示例批改如下：

internal/db/dao.go

package db

import "database/sql"

type Dao interface { // 接口申明
    Version() (string, error)
}

type dao struct { // 默认实现
    db *sql.DB
}

func (d dao) Version() (string, error) {
    var version string
    row := d.db.QueryRow("SELECT VERSION()")
    if err := row.Scan(&version); err != nil {
        return "", err
    }
    return version, nil
}

func NewDao(db *sql.DB) *dao { // 生成dao对象的办法
    return &dao{db: db}
}

NewDao

var Provider = wire.NewSet(New, NewDao)

cmd/main.go文件批改：

package main

import (
    "log"
    "wire-example2/internal/db"
)

type App struct {
    dao db.Dao // 依赖Dao接口
}

func NewApp(dao db.Dao) *App { // 依赖Dao接口
    return &App{dao: dao}
}

func main() {
    app, cleanup, err := InitApp()
    if err != nil {
        log.Fatal(err)
    }
    defer cleanup()
    version, err := app.dao.Version() // 调用Dao接口办法
    if err != nil {
        log.Fatal(err)
    }
    log.Println(version)
}

wire

C:\Users\Administrator\GolandProjects\wire-example2\cmd>wire
wire: C:\Users\Administrator\GolandProjects\wire-example2\cmd\wire.go:11:1: inject InitApp: no provider found for wire-example2/internal/db.Dao
        needed by *wire-example2/cmd.App in provider "NewApp" (C:\Users\Administrator\GolandProjects\wire-example2\cmd\main.go:12:6)
wire: wire-example2/cmd: generate failed
wire: at least one generate failure

wireinject InitApp: no provider found for wire-example2/internal/db.Daodb.DaoProviderdb.daoProvider

internal/db/db.goProviderdb.*daodb.Dao

var Provider = wire.NewSet(New, NewDao, wire.Bind(new(Dao), new(*dao)))

wire.Bind()interface{}实现

wire

结尾

wire