golang不到30行代碼實現(xiàn)依賴注入的方法

更新時間：2018年07月27日 08:28:45 作者：xialeistudio

這篇文章主要介紹了golang不到30行代碼實現(xiàn)依賴注入的方法,小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

本文介紹了golang不到30行代碼實現(xiàn)依賴注入的方法，分享給大家，具體如下：

項目地址

go-di-demo

本項目依賴

使用標(biāo)準(zhǔn)庫實現(xiàn)，無額外依賴

依賴注入的優(yōu)勢

用java的人對于spring框架一定不會陌生，spring核心就是一個IoC(控制反轉(zhuǎn)/依賴注入)容器，帶來一個很大的優(yōu)勢是解耦。一般只依賴容器，而不依賴具體的類，當(dāng)你的類有修改時，最多需要改動一下容器相關(guān)代碼，業(yè)務(wù)代碼并不受影響。

golang的依賴注入原理

總的來說和java的差不多，步驟如下：(golang不支持動態(tài)創(chuàng)建對象，所以需要先手動創(chuàng)建對象然后注入，java可以直接動態(tài)創(chuàng)建對象)

通過反射讀取對象的依賴(golang是通過tag實現(xiàn))
在容器中查找有無該對象實例
如果有該對象實例或者創(chuàng)建對象的工廠方法，則注入對象或使用工廠創(chuàng)建對象并注入
如果無該對象實例，則報錯

代碼實現(xiàn)

一個典型的容器實現(xiàn)如下，依賴類型參考了spring的singleton/prototype，分別對象單例對象和實例對象:

package di

import (
 "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()
}

// 設(shè)置實例對象工廠
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
}

// 打印容器內(nèi)部實例
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")
}

最重要的是Ensure方法，該方法掃描實例的所有export字段，并讀取di標(biāo)簽，如果有該標(biāo)簽則啟動注入。
判斷di標(biāo)簽的類型來確定注入singleton或者prototype對象

測試

單例對象在整個容器中只有一個實例，所以不管在何處注入，獲取到的指針一定是一樣的。
實例對象是通過同一個工廠方法創(chuàng)建的，所以每個實例的指針不可以相同。

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

package main

import (
 "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)
}

執(zhí)行之后打印出來的結(jié)果為：