一文带你搞懂Golang依赖注入的设计与实现

type A struct {
}

type B struct {
	a A
}

type C struct {
	b B
}

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

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

// 依赖注入容器
type Injector interface {
    Applicator
    Invoker
    TypeMapper
    // 上一级 Injector
    SetParent(Injector)
}

// 给结构体字段注入依赖
type Applicator interface {
    Apply(interface{}) error
}

// 调用函数，Invoke 的参数是被调用的函数，
// 这个函数的参数事先通过 Injector 注入，
// 调用的时候从 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
}

type injector struct {
    // 注入的依赖
    values map[reflect.Type]reflect.Value
    // 上级 Injector
    parent Injector
}

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

func (inj *injector) callInvoke(f interface{}, t reflect.Type, numIn int) ([]reflect.Value, error) {
    // 参数切片，用来保存从 Injector 里面获取的依赖
    var in []reflect.Value
    // 只有 f 有参数的时候，才需要从 Injector 获取依赖
    if numIn > 0 {
    // 初始化切片
        in = make([]reflect.Value, numIn)
	var argType reflect.Type
	var val reflect.Value
        // 遍历 f 参数
	for i := 0; i < numIn; i++ {
            // 获取 f 参数类型
            argType = t.In(i)
            // 从 Injector 获取该类型对应的依赖
	    val = inj.Value(argType)
            // 如果函数参数未注入，则调用出错
	    if !val.IsValid() {
                return nil, fmt.Errorf("value not found for type %v", argType)
            }

            // 保存从 Injector 获取到的值
            in[i] = val
        }
    }
    // 通过反射调用 f 函数，in 是参数切片
    return reflect.ValueOf(f).Call(in), nil
}

// 参数 val 是待注入依赖的结构体
func (inj *injector) Apply(val interface{}) error {
    v := reflect.ValueOf(val)

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

    // 底层类型不是结构体则返回
    if v.Kind() != reflect.Struct {
	return nil // Should not panic here ?
    }

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

    // 遍历结构体的字段
    for i := 0; i < v.NumField(); i++ {
        // 获取第 i 个结构体字段
        // v 的类型是 reflect.Value
        // v.Field 返回的是结构体字段的值
        f := v.Field(i)
        // t 的类型是 *reflect.rtype
        // t.Field 返回的是 reflect.Type，是类型信息
	structField := t.Field(i)
        // 检查是否有 inject tag，有这个 tag 才会进行依赖注入
	_, ok := structField.Tag.Lookup("inject")
        // 字段支持反射设置，并且存在 inject tag 才会进行注入
	if f.CanSet() && ok {
            // 通过反射类型从 Injector 中获取对应的值
            ft := f.Type()
            v := inj.Value(ft)
            // 获取不到注入的依赖，则返回错误
            if !v.IsValid() {
		return fmt.Errorf("value not found for type %v", ft)
            }

            // 设置结构体字段值
            f.Set(v)
	}

    }
    return nil
}

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

// 新建依赖注入容器
inj := injector{
    values: make(map[reflect.Type]reflect.Value),
}
// 注入依赖 c
inj.Map(c)
// 调用函数 test，test 的参数 `C` 会通过依赖注入容器获取
_, _ = inj.Invoke(test)
// 输出 "c called"