在現(xiàn)代的 web 框架里面，基本都有實(shí)現(xiàn)了依賴注入的功能，可以讓我們很方便地對(duì)應(yīng)用的依賴進(jìn)行管理，同時(shí)免去在各個(gè)地方 new 對(duì)象的麻煩。比如 Laravel 里面的 Application，又或者 Java 的 Spring 框架也自帶依賴注入功能。

今天我們來(lái)看看 go 里面實(shí)現(xiàn)依賴注入的一種方式，以 flamego 里的 inject 為例子。

我們要了解一個(gè)軟件的設(shè)計(jì)，先要看它定義了一個(gè)什么樣的模型，但是在了解模型之前，我們更應(yīng)該清楚了解，為什么會(huì)出現(xiàn)這個(gè)模型，也就是我們構(gòu)建出了這個(gè)模型到底是為了解決什么問(wèn)題。

依賴注入要解決的問(wèn)題

我們先來(lái)看看，在沒(méi)有依賴注入之前，我們需要的依賴是如何構(gòu)建出來(lái)的，假設(shè)有如下 struct 定義：

type A struct {
}

type B struct {
	a A
}

type C struct {
	b B
}

func test(c C) {
    println("c called")
}

假設(shè)我們要調(diào)用 test，就需要?jiǎng)?chuàng)建一個(gè) C 的實(shí)例，而創(chuàng)建 C 的實(shí)例需要?jiǎng)?chuàng)建一個(gè) B 的實(shí)例，而創(chuàng)建 B 的實(shí)例需要一個(gè) A 的實(shí)例。如下是一個(gè)例子：

a := A{}
b := B{a: a}
c := C{b: b}
test(c)

我們可以看到，這個(gè)過(guò)程非常的繁瑣，只有一個(gè)地方需要這樣調(diào)用 test 還好，如果有多個(gè)地方都需要調(diào)用 test，那我們就要做很多創(chuàng)建實(shí)例的操作，而且一旦實(shí)例的構(gòu)建過(guò)程發(fā)生變化，我們就需要改動(dòng)很多地方。

所以現(xiàn)在的 web 框架里面一般都將這個(gè)實(shí)例化的過(guò)程固化下來(lái)，在框架的某個(gè)地方注冊(cè)一些實(shí)例化的函數(shù)，在我們需要的時(shí)候就調(diào)用之前注冊(cè)的實(shí)例化的函數(shù)，實(shí)例化之后，再根據(jù)需要看看是否需要將這個(gè)實(shí)例保留在內(nèi)存里面，從而在免去了手動(dòng)實(shí)例化的過(guò)程之外，節(jié)省我們資源的開(kāi)銷（不用每次使用的時(shí)候都實(shí)例化一次）。

而這里說(shuō)到的固化的實(shí)例化過(guò)程，其實(shí)就是我們本文所說(shuō)的依賴注入。在 Laravel 里面我們可以通過(guò) ServiceProvider 的 app()->register() 或者 app()->bind() 等函數(shù)來(lái)做依賴注入的一些操作。

inject 依賴注入模型/設(shè)計(jì)

以下是 Injector 的大概模型，Injector 接口里面嵌套了 Applicator、Invoker、TypeMapper 接口，之所以這樣做是出于接口隔離原則考慮，因?yàn)檫@三者代表了細(xì)化的三種不同功能，分離出不同的接口可以讓我們的代碼更加的清晰，也會(huì)更利于代碼的后續(xù)演進(jìn)。

• Injector：依賴注入容器
• Applicator：結(jié)構(gòu)體注入的接口
• Invoker：使用注入的依賴來(lái)調(diào)用函數(shù)
• TypeMapper：類型映射，需要特別注意的是，在 Injector 里面，是通過(guò)類型來(lái)綁定依賴（不同于 Laravel 的依賴注入容器可以通過(guò)字符串命名的方式來(lái)綁定依賴，當(dāng)然將 Injector 稍微改改也是可以實(shí)現(xiàn)的，就看有沒(méi)有這種需求罷了）。

// 依賴注入容器
type Injector interface {
    Applicator
    Invoker
    TypeMapper
    // 上一級(jí) Injector
    SetParent(Injector)
}

// 給結(jié)構(gòu)體字段注入依賴
type Applicator interface {
    Apply(interface{}) error
}

// 調(diào)用函數(shù)，Invoke 的參數(shù)是被調(diào)用的函數(shù)，
// 這個(gè)函數(shù)的參數(shù)事先通過(guò) Injector 注入，
// 調(diào)用的時(shí)候從 Injector 里面獲取依賴
type Invoker interface {
    Invoke(interface{}) ([]reflect.Value, error)
}

// 往 Injector 注入依賴
type TypeMapper interface {
    Map(...interface{}) TypeMapper
    MapTo(interface{}, interface{}) TypeMapper
    Set(reflect.Type, reflect.Value) TypeMapper
    Value(reflect.Type) reflect.Value
}

表示成圖像大概如下：

我們可以通過(guò) Injector 的 TypeMapper 來(lái)往依賴注入容器里面注入依賴，然后在我們需要為結(jié)構(gòu)體的字段注入依賴，又或者為函數(shù)參數(shù)注入依賴的時(shí)候，可以通過(guò) Applicator 或者 Invoker 來(lái)實(shí)現(xiàn)注入依賴。

而 SetParent 這個(gè)方法比較有意思，它其實(shí)將 Injector 這個(gè)模型拓展了，形成了一個(gè)有父子關(guān)系的模型。在其他語(yǔ)言里面可能作用不是很明顯，但是在 go 里面，這個(gè)父子模型恰好和 go 的協(xié)程的父子模型一致。在 go 里面，我們可以在一個(gè)協(xié)程里面再創(chuàng)建一個(gè) Injector，然后在這里面定義一些在當(dāng)前協(xié)程以及當(dāng)前協(xié)程子協(xié)程可以用到的一些依賴，而不用影響外部的 Injector。

當(dāng)然上面說(shuō)到的協(xié)程只是 Injector 里面 SetParent 的一種用法，另外一種用法是，我們的 web 應(yīng)用往往會(huì)根據(jù)路由前綴來(lái)劃分為不同的組，而這種路由組的結(jié)構(gòu)組織方式其實(shí)也是一種父子結(jié)構(gòu)，在這種場(chǎng)景下，我們就可以針對(duì)全局注入一些依賴的情況下，再針對(duì)某個(gè)路由組來(lái)注入路由組特定的依賴。

injector 的依賴注入實(shí)現(xiàn)

我們來(lái)看看 injector 的結(jié)構(gòu)體：

type injector struct {
    // 注入的依賴
    values map[reflect.Type]reflect.Value
    // 上級(jí) Injector
    parent Injector
}

這個(gè)結(jié)構(gòu)體定義很簡(jiǎn)單，就只有兩個(gè)字段，values 和 parent，我們通過(guò) TypeMapper 注入的依賴都保存在 values 里面，values 是通過(guò)反射來(lái)記錄我們注入的參數(shù)類型和值的。

那我們是如何注入依賴的呢？再來(lái)看看 TypeMapper 的 Map 方法：

func (inj *injector) Map(values ...interface{}) TypeMapper {
    for _, val := range values {
	inj.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
    }
    return inj
}

我們可以看到，對(duì)于傳入給 Map 的參數(shù)，這里獲取了它的反射類型作為 values map 的 key，而獲取了傳入?yún)?shù)的反射值作為 values 里面 map 的值。其他的兩個(gè)方法 MapTo、Set 也是類似的功能，最終的效果都是獲取依賴的類型作為 values 的 key，依賴的值作為 values 的值。

到此為止，我們知道 Injector 是如何注入依賴的了。

那么它又是如何去從依賴注入容器里面拿到我們注入的數(shù)據(jù)的呢？又是如何使用這些數(shù)據(jù)的呢？

我們?cè)賮?lái)看看 callInvoke 方法（也就是 Injector 的 Invoke 實(shí)現(xiàn)）：

func (inj *injector) callInvoke(f interface{}, t reflect.Type, numIn int) ([]reflect.Value, error) {
    // 參數(shù)切片，用來(lái)保存從 Injector 里面獲取的依賴
    var in []reflect.Value
    // 只有 f 有參數(shù)的時(shí)候，才需要從 Injector 獲取依賴
    if numIn > 0 {
    // 初始化切片
        in = make([]reflect.Value, numIn)
	var argType reflect.Type
	var val reflect.Value
        // 遍歷 f 參數(shù)
	for i := 0; i < numIn; i++ {
            // 獲取 f 參數(shù)類型
            argType = t.In(i)
            // 從 Injector 獲取該類型對(duì)應(yīng)的依賴
	    val = inj.Value(argType)
            // 如果函數(shù)參數(shù)未注入，則調(diào)用出錯(cuò)
	    if !val.IsValid() {
                return nil, fmt.Errorf("value not found for type %v", argType)
            }

            // 保存從 Injector 獲取到的值
            in[i] = val
        }
    }
    // 通過(guò)反射調(diào)用 f 函數(shù)，in 是參數(shù)切片
    return reflect.ValueOf(f).Call(in), nil
}

參數(shù)和返回值說(shuō)明：

• 第一個(gè)參數(shù)是我們 Invoke 的函數(shù)，這個(gè)函數(shù)的參數(shù)，都會(huì)通過(guò) Injector 根據(jù)函數(shù)參數(shù)類型獲取
• 第二個(gè)參數(shù) f 的反射類型，也就是 reflect.TypeOf(f)
• 第三個(gè)參數(shù)是 f 的參數(shù)個(gè)數(shù)
• 返回值是 reflect.Value 切片，如果我們?cè)谡{(diào)用過(guò)程出錯(cuò)，返回 error

在這個(gè)函數(shù)中，會(huì)通過(guò)反射來(lái)獲取 f 的參數(shù)類型（reflect.Type），拿到這個(gè)類型之后，從 Injector 里面獲取我們之前注入的依賴，這樣我們就可以拿到所有參數(shù)對(duì)應(yīng)的值。最后，通過(guò) reflect.ValueOf(f) 來(lái)調(diào)用 f 函數(shù)，參數(shù)是我們從 Injector 獲取到的值的切片。調(diào)用之后，返回函數(shù)調(diào)用結(jié)果，一個(gè) reflect.Value 切片。

當(dāng)然，這只是其中一種使用依賴的方式，另外一種方式也比較常見(jiàn)，就是為結(jié)構(gòu)體注入依賴，這跟 hyperf 里面通過(guò)注釋注解又或者 Spring 里面的注入方式有點(diǎn)類似。在 Injector 里面是通過(guò) Apply 來(lái)為結(jié)構(gòu)體字段注入依賴的：

// 參數(shù) val 是待注入依賴的結(jié)構(gòu)體
func (inj *injector) Apply(val interface{}) error {
    v := reflect.ValueOf(val)

    // 獲取底層元素
    for v.Kind() == reflect.Ptr {
	v = v.Elem()
    }

    // 底層類型不是結(jié)構(gòu)體則返回
    if v.Kind() != reflect.Struct {
	return nil // Should not panic here ?
    }

    // v 的反射類型
    t := v.Type()

    // 遍歷結(jié)構(gòu)體的字段
    for i := 0; i < v.NumField(); i++ {
        // 獲取第 i 個(gè)結(jié)構(gòu)體字段
        // v 的類型是 reflect.Value
        // v.Field 返回的是結(jié)構(gòu)體字段的值
        f := v.Field(i)
        // t 的類型是 *reflect.rtype
        // t.Field 返回的是 reflect.Type，是類型信息
	structField := t.Field(i)
        // 檢查是否有 inject tag，有這個(gè) tag 才會(huì)進(jìn)行依賴注入
	_, ok := structField.Tag.Lookup("inject")
        // 字段支持反射設(shè)置，并且存在 inject tag 才會(huì)進(jìn)行注入
	if f.CanSet() && ok {
            // 通過(guò)反射類型從 Injector 中獲取對(duì)應(yīng)的值
            ft := f.Type()
            v := inj.Value(ft)
            // 獲取不到注入的依賴，則返回錯(cuò)誤
            if !v.IsValid() {
		return fmt.Errorf("value not found for type %v", ft)
            }

            // 設(shè)置結(jié)構(gòu)體字段值
            f.Set(v)
	}

    }
    return nil
}

簡(jiǎn)單來(lái)說(shuō)，Injector 里面，通過(guò) TypeMapper 來(lái)注入依賴，然后通過(guò) Apply 或者 Invoke 來(lái)使用注入的依賴。

例子

還是以一開(kāi)始的例子為例，通過(guò)依賴注入的方式來(lái)改造一下：

a := A{}
b := B{a: a}
c := C{b: b}

// 新建依賴注入容器
inj := injector{
    values: make(map[reflect.Type]reflect.Value),
}
// 注入依賴 c
inj.Map(c)
// 調(diào)用函數(shù) test，test 的參數(shù) `C` 會(huì)通過(guò)依賴注入容器獲取
_, _ = inj.Invoke(test)
// 輸出 "c called"

這個(gè)例子中，我們通過(guò) inj.Map 來(lái)注入了依賴，在后續(xù)通過(guò) inj.Invoke 來(lái)調(diào)用 test 函數(shù)的時(shí)候，將會(huì)從依賴注入容器里面獲取 test 的參數(shù)，然后將這些參數(shù)傳入 test 來(lái)調(diào)用。

這個(gè)例子也許比較簡(jiǎn)單，但是如果我們很多地方都需要用到 C 這個(gè)參數(shù)的話，我們通過(guò) inj.Invoke 的方式來(lái)調(diào)用函數(shù)就可以避免每一次調(diào)用都要實(shí)例化 C 的繁瑣操作了。

以上就是一文帶你搞懂Golang依賴注入的設(shè)計(jì)與實(shí)現(xiàn)的詳細(xì)內(nèi)容，更多關(guān)于Golang依賴注入的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！