分解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信息，再调用node的Call方法进行递规的调用。
形参有下面几种类型
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可以包含 paramSingle和paramGroupedSlice类型。
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可以包含resultSingle和resultGrouped
容器
在调用container := dig.New()的时候就会创建一个容器，所有Provide进行注册的函数都会组成容器的节点node，node组成了`容器的核心
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)
}
