golang不到30行代碼實現依賴注入

項目地址

go-di-demo

本項目依賴

使用標準庫實現，無額外依賴

依賴注入的優勢

用java的人對於spring架構一定不會陌生，spring核心就是一個IoC(控制反轉/依賴注入)容器，帶來一個很大的優勢是解耦。一般只依賴容器，而不依賴具體的類，當你的類有修改時，最多需要改動一下容器相關代碼，業務代碼並不受影響。

golang的依賴注入原理

總的來說和java的差不多，步驟如下：(golang不支援動態建立對象，所以需要先手動建立對象然後注入，java可以直接動態建立對象)

1. 通過反射讀取對象的依賴(golang是通過tag實現)
2. 在容器中尋找有無該對象執行個體
3. 如果有該對象執行個體或者建立對象的Factory 方法，則注入對象或使用工廠建立對象並注入
4. 如果無該對象執行個體，則報錯

代碼實現

一個典型的容器實現如下，依賴類型參考了spring的singleton/prototype，分別對象單例對象和執行個體對象:

package diimport (    "sync"    "reflect"    "fmt"    "strings"    "errors")var (    ErrFactoryNotFound = errors.New("factory not found"))type factory = func() (interface{}, error)// 容器type Container struct {    sync.Mutex    singletons map[string]interface{}    factories  map[string]factory}// 容器執行個體化func NewContainer() *Container {    return &Container{        singletons: make(map[string]interface{}),        factories:  make(map[string]factory),    }}// 註冊單例對象func (p *Container) SetSingleton(name string, singleton interface{}) {    p.Lock()    p.singletons[name] = singleton    p.Unlock()}// 擷取單例對象func (p *Container) GetSingleton(name string) interface{} {    return p.singletons[name]}// 擷取執行個體對象func (p *Container) GetPrototype(name string) (interface{}, error) {    factory, ok := p.factories[name]    if !ok {        return nil, ErrFactoryNotFound    }    return factory()}// 設定執行個體對象工廠func (p *Container) SetPrototype(name string, factory factory) {    p.Lock()    p.factories[name] = factory    p.Unlock()}// 注入依賴func (p *Container) Ensure(instance interface{}) error {    elemType := reflect.TypeOf(instance).Elem()    ele := reflect.ValueOf(instance).Elem()    for i := 0; i < elemType.NumField(); i++ { // 遍曆欄位        fieldType := elemType.Field(i)        tag := fieldType.Tag.Get("di") // 擷取tag        diName := p.injectName(tag)        if diName == "" {            continue        }        var (            diInstance interface{}            err        error        )        if p.isSingleton(tag) {            diInstance = p.GetSingleton(diName)        }        if p.isPrototype(tag) {            diInstance, err = p.GetPrototype(diName)        }        if err != nil {            return err        }        if diInstance == nil {            return errors.New(diName + " dependency not found")        }        ele.Field(i).Set(reflect.ValueOf(diInstance))    }    return nil}// 擷取需要注入的依賴名稱func (p *Container) injectName(tag string) string {    tags := strings.Split(tag, ",")    if len(tags) == 0 {        return ""    }    return tags[0]}// 檢測是否單例依賴func (p *Container) isSingleton(tag string) bool {    tags := strings.Split(tag, ",")    for _, name := range tags {        if name == "prototype" {            return false        }    }    return true}// 檢測是否執行個體依賴func (p *Container) isPrototype(tag string) bool {    tags := strings.Split(tag, ",")    for _, name := range tags {        if name == "prototype" {            return true        }    }    return false}// 列印容器內部執行個體func (p *Container) String() string {    lines := make([]string, 0, len(p.singletons)+len(p.factories)+2)    lines = append(lines, "singletons:")    for name, item := range p.singletons {        line := fmt.Sprintf("  %s: %x %s", name, &item, reflect.TypeOf(item).String())        lines = append(lines, line)    }    lines = append(lines, "factories:")    for name, item := range p.factories {        line := fmt.Sprintf("  %s: %x %s", name, &item, reflect.TypeOf(item).String())        lines = append(lines, line)    }    return strings.Join(lines, "\n")}

1. 最重要的是Ensure方法，該方法掃描執行個體的所有export欄位，並讀取di標籤，如果有該標籤則啟動注入。
2. 判斷di標籤的類型來確定注入singleton或者prototype對象

測試

1. 單例對象在整個容器中只有一個執行個體，所以不管在何處注入，擷取到的指標一定是一樣的。
2. 執行個體對象是通過同一個Factory 方法建立的，所以每個執行個體的指標不可以相同。

下面是測試入口代碼，完整代碼在github倉庫，有興趣的可以翻閱：

package mainimport (    "di"    "database/sql"    "fmt"    "os"    _ "github.com/go-sql-driver/mysql"    "demo")func main() {    container := di.NewContainer()    db, err := sql.Open("mysql", "root:root@tcp(localhost)/sampledb")    if err != nil {        fmt.Printf("error: %s\n", err.Error())        os.Exit(1)    }    container.SetSingleton("db", db)    container.SetPrototype("b", func() (interface{}, error) {        return demo.NewB(), nil    })    a := demo.NewA()    if err := container.Ensure(a); err != nil {        fmt.Println(err)        return    }    // 列印指標，確保單例和執行個體的指標地址    fmt.Printf("db: %p\ndb1: %p\nb: %p\nb1: %p\n", a.Db, a.Db1, &a.B, &a.B1)}

執行之後列印出來的結果為：

db: 0xc4200b6140db1: 0xc4200b6140b: 0xc4200a0330b1: 0xc4200a0338

可以看到兩個db執行個體的指標一樣，說明是同一個執行個體，而兩個b的指標不同，說明不是一個執行個體。

寫在最後

通過依賴注入可以很好的管理多個對象之間的執行個體化以及依賴關係，配合設定檔在應用初始化階段將需要注入的執行個體註冊到容器中，在應用的任何地方只需要在執行個體化時注入容器即可。沒有額外依賴。

個人部落格

www.ddhigh.com