golang martini 源码阅读笔记之inject

martini是go语言写的一个超级轻量的web开源框架，具体源码可在github搜索找到。13年那会开始接触go语言时有稍微看过这个框架，由于之后没有继续使用go就慢慢忽略了，最近由于手头项目可能会用到，因此又想起这个框架。

github上显示该项目更新不断，说明真是个好框架，简洁高效的东西从来都不缺少拥护者。周末阅读martini源码时做了注释写下一些理解，主要是inject.go以及martini.go两个文件，后续估计还会再阅读路由功能的主要文件。

注：以下的'泛型'均表示interface{}类型

inject.go

package inject

import (
    "fmt"
    "reflect"
)

// 实现回调函数参数值的注入，通观martini框架，Injector就是用于存储中间件函数以及用户自定义函数回调时的参数
type Injector interface {
    Applicator // 结构体各个字段赋值
    Invoker     // 通过反射实现函数调用的接口
    TypeMapper  // 类型映射接口，TypeMapper 的功能与系统设计初衷有关系吧，mapper根据类型为键值key，同一类型只有一个value与之对应
    SetParent(Injector)
}

// 为结构体类型的各个字段进行动态赋值
type Applicator interface {
    // 为结构体定义中，带有'inject'标签的字段进行赋值
    Apply(interface{}) error
}

// 通过反射的方式实现函数调用
type Invoker interface {
    // 参数类型为函数类型，使用反射获取函数参数类型，根据各个参数类型获取对应的值，并调用该函数
    Invoke(interface{}) ([]reflect.Value, error)
}

// 参数值与类型的映射接口
type TypeMapper interface {
    // 具体类型的映射,根据值的具体类型直接建立映射
    Map(interface{}) TypeMapper 
    // ’泛型‘与具体类型之间的映射，第二个参数必须是泛型的指针类型
    // 因为这里只需要获得泛型的类型，只有泛型的指针代价最小了，因为只需要用到它的type部分
    // 这里需要理解interface{}的具体实现
    MapTo(interface{}, interface{}) TypeMapper 
    Set(reflect.Type, reflect.Value) TypeMapper
    Get(reflect.Type) reflect.Value // 根据类型查找值
}

//这里类似于将所有的golang类型分为两种大的类型：泛型 interface{}与具体类型concrete type
type injector struct {
    values map[reflect.Type]reflect.Value // 存储上述过程中结构体字段的值，以及函数调用参数的值
    parent Injector // 
}

// 查询 value 的接口类型, 适用于interface{}类型的映射, 如果value不是指针类型将会返回异常
// 这个接口只是用在泛型映射，因此只需要从value(interface{})中获取type部分
func InterfaceOf(value interface{}) reflect.Type {
    t := reflect.TypeOf(value) // 获取type的值

    for t.Kind() == reflect.Ptr { // 如果是指针，继续查指针的指向
        t = t.Elem() // 指针指向的元素 
    }

    if t.Kind() != reflect.Interface { // 最后肯定是指向interface 了，如果不是，说明传入的参数有问题
        panic("Called inject.InterfaceOf with a value that is not a pointer to an interface. (*MyInterface)(nil)")
    }

    return t
}

// New returns a new Injector.
//创建一个注入工具，提供数据存储与查询，其他功能主要还是依赖于反射库的实现
func New() Injector {
    return &injector{
        values: make(map[reflect.Type]reflect.Value),
    }
}

// 参数类型为函数func，使用反射接口完成函数的调用
func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
    t := reflect.TypeOf(f) //获取f的类型部分，这里为函数类型

    var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func // 创建存储参数的空间
    for i := 0; i < t.NumIn(); i++ {
        argType := t.In(i)
        val := inj.Get(argType) // 根据参数类型获取参数的值,从这里也可以看出同一种类型，只有一个值
        if !val.IsValid() {
            return nil, fmt.Errorf("Value not found for type %v", argType)
        }

        in[i] = val
    }

    // 反射类型的函数调用，取出f中的数据部分，即实例值函数
    return reflect.ValueOf(f).Call(in), nil // 函数调用
}

// 为结构体赋值的具体实现
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 ?
    }

    t := v.Type() // 获取结构体的类型

    for i := 0; i < v.NumField(); i++ { // 获取字段的数量
        f := v.Field(i)
        structField := t.Field(i)
        // 带有'inject'标签的才可能被赋值
        if f.CanSet() && (structField.Tag == "inject" || structField.Tag.Get("inject") != "") {
            ft := f.Type()
            v := inj.Get(ft)
            if !v.IsValid() {
                return fmt.Errorf("Value not found for type %v", ft)
            }

            f.Set(v)
        }

    }

    return nil
}

// 具体类型参数，类型与值的映射
func (i *injector) Map(val interface{}) TypeMapper {
    //类型与值的映射
    i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
    return i
}

// 泛型类型的映射
func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
    //需要先获取泛型指针指向的具体泛型类型
    i.values[InterfaceOf(ifacePtr)] = reflect.ValueOf(val)
    return i
}

func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
    i.values[typ] = val
    return i
}

//  根据类型查找值
func (i *injector) Get(t reflect.Type) reflect.Value {
    val := i.values[t] // 先进行简单类型的查询

    if val.IsValid() {
        return val
    }

    // no concrete types found, try to find implementors
    // if t is an interface
    if t.Kind() == reflect.Interface { // t 为 interface 类型
        for k, v := range i.values {  // 迭代查询
            if k.Implements(t) {    // 对于每一个类型，看是否实现了t接口
                val = v
                break
            }
        }
    }
    // 找不到，就去父亲节点找
    // Still no type found, try to look it up on the parent
    if !val.IsValid() && i.parent != nil {
        val = i.parent.Get(t) 
    }

    return val

}

func (i *injector) SetParent(parent Injector) {
    i.parent = parent
}

如理解有错误，欢迎在评论指出，不胜感激！