分解uber依賴注入庫dig-源碼分析

上一篇帖子 分解uber依賴注入庫dig-使用篇 把如何使用dig進行程式碼示例說明,這篇帖子分析dig的源碼,看他是如何實現依賴注入的。

dig實現的中心思想:所有傳入Provide的函數必須要有除error外的返回參數,返回參數供其他函數的形參使用。

比如上一篇的第一個例子里,一個函數func() (*Config, error)返回Config 另一個函數func(cfg *Config) *log.Logger的形參使用了Config

整體調用流程

簡單說一下整體的調用流程,具體的細節再一點點展開說明。
傳入給Provide里的函數並不會直接被調用,dig只會對這些函數進行分析,提取函數的形參和返回參數,根據返回參數來組織容器結構(這個後面會詳細說)。只有在調用Invoke的時候才
會根據傳入的函數的形參進行查詢和調用返回這些形參的函數。還以上一篇的第一個例子進行說明
一共有兩個Provide方法進行了函數註冊

c.Provide(func() (*Config, error))
c.Provide(func(cfg *Config) *log.Logger)

調用Invoke方法c.Invoke(func(l *log.Logger))Invoke方法,通過對傳入函數形參的分析,形參里有*log.Logger去容器里找哪個函數的返回類型有*log.Logger,找到方法func(cfg *Config) *log.Logger
發現這個函數有形參cfg *Config再去找返回參數有*Config的函數,找到了func() (*Config, error)形參為空,停止查詢,進行函數的調用,把返回的*Config傳遞給func(cfg *Config) *log.Logger,進行
方法調用再把返回的*log.Logger傳給c.Invoke(func(l *log.Logger))進行函數的調用執行

所以在寫Prvoide註冊函數的時候,順序隨便寫也不會問題,只要Invoke時能查找到相應的函數就可以。
上面簡單說了一下流程,提一個問題:如果是組參數,比如上一篇-組的例子只有多個函數返回了StudentList []*Student group:”stu,flatten”“,在Invoke時怎麼處理?
先留一個扣子,下面的內容會進行詳細說明。

分析傳入的函數

Provide把函數添加到容器內,dig會把傳入的函數進行分析,

利用go的反射機制,提取函數的形參和返回參數組成一個node,下圖是node所有欄位的詳細說明

主要看一下形參paramList和返回參數resultList兩個欄位

paramList

一個函數所有的形參資訊都會放入到paramList

type param interface {
	fmt.Stringer
	// 構建所有依賴的函數,調用返回函數的值
	Build(containerStore) (reflect.Value, error)
	// 在生成dot文件時使用
	DotParam() []*dot.Param
}

Build方法是很重要的一個方法,他會構建所有依賴的函數,調用返回函數的值,比如注入函數c.Provide(func(cfg *Config) *log.Logger) 的形參cfg *Config會被解析為paramList的一個元素,在調用Build方法時,
會去容器里查找有返回*log.Logger的注入函數的node資訊,再調用nodeCall方法進行遞規的調用。
形參有下面幾種類型

paramSingle

paramSingle好理解,注入函數的一般形參比如int、string、struct、slice都屬於paramSingle

paramGroupedSlice

paramGroupedSlice組類型,比如上一篇帖子中的例子

container.Provide(NewUser("tom", 3), dig.Group("stu"))
和
		StudentList []*Student `group:"stu"`

都是組類型。

paramObject

paramObject 嵌入dig.In的結構體類型,比如上一篇帖子中的例子

	type DBInfo struct {
		dig.In
		PrimaryDSN   *DSN `name:"primary"`
		SecondaryDSN *DSN `name:"secondary"`
	}

paramObject可以包含 paramSingleparamGroupedSlice類型。

resultList

type result interface {
	// Extracts the values for this result from the provided value and
	// stores them into the provided containerWriter.
	Extract(containerWriter, reflect.Value)

	// 生成dot文件時調用
	DotResult() []*dot.Result
}

Extract(containerWriter, reflect.Value)從容器里提取到相應類型並給他賦值,比如注入函數c.Provide(func(cfg *Config) *log.Logger)*log.Logger是一個resultSingle,在調用Extract時就是把reflect.Value的值賦給他。

返回參數有下面幾種類型

resultList

node的所有返回參數都保存在resultList

resultSingle

resultSingle 單獨的一個返回參數,注入函數的一般返回參數比如int、string、struct、slice都屬於他

resultGrouped

resultGrouped組類型
比如上一篇帖子中的

container.Provide(NewUser("tom", 3), dig.Group("stu"))
和
StudentList []*Student `group:"stu"`

resultObject

resultObject 嵌入dig.Out的結構體類型,上一篇的例子中

	type DSNRev struct {
		dig.Out
		PrimaryDSN   *DSN `name:"primary"`
		SecondaryDSN *DSN `name:"secondary"`
	}

resultObject可以包含resultSingleresultGrouped

容器

在調用container := dig.New()的時候就會創建一個容器,所有Provide進行註冊的函數都會組成容器的節點nodenode組成了`容器的核心

type Container struct {
	providers map[key][]*node
	nodes []*node
	values map[key]reflect.Value
	groups map[key][]reflect.Value
	rand *rand.Rand
	isVerifiedAcyclic bool
	deferAcyclicVerification bool
	invokerFn invokerFn
}


providers map[key][]*node這個key是非常重要的一個參數,他是node對應的函數的返回值

type key struct {
	t reflect.Type
	// Only one of name or group will be set.
	name  string
	group string
}

name命名參數和group組不能同時存在,上一篇程式碼示例的時候就有說過。
看這一段程式碼

	case resultSingle:
		k := key{name: r.Name, t: r.Type}
		cv.keyPaths[k] = path
		// .......
	case resultGrouped:
		k := key{group: r.Group, t: r.Type}
		cv.keyPaths[k] = path
	}

其中的t: r.Type就是返回值參數的類型,也就是說是providers map[key][]*node這個字典,key是返回值資訊[]*node是提供這個返回值的函數,為什麼是個slice,因為像組那樣的返回值是有多個函數提供的。
這裡要說一下組是如何做的,也回答上面留的問題,我們的示例程式碼

	type Rep struct {
		dig.Out
		StudentList []*Student `group:"stu,flatten"`
	}
	if err := container.Provide(NewUser("tom", 3)); err != nil {
		t.Fatal(err)
	}
	if err := container.Provide(NewUser("jerry", 1)); err != nil {
		t.Fatal(err)
	

有多個函數返回了[]*Student,dig會解析成
key{name: "stu", t: 類型的Type},做為字典的key,有兩個Provide里的注入函數,

在調用Extract方法時,給groups map[key][]reflect.Value賦值

func (rt resultGrouped) Extract(cw containerWriter, v reflect.Value) {
	if !rt.Flatten {
		cw.submitGroupedValue(rt.Group, rt.Type, v)
		return
	}
	for i := 0; i < v.Len(); i++ {
		cw.submitGroupedValue(rt.Group, rt.Type, v.Index(i))
	}
}

func (c *Container) submitGroupedValue(name string, t reflect.Type, v reflect.Value) {
	k := key{group: name, t: t}
	c.groups[k] = append(c.groups[k], v)
}