go利用(*interface{})(nil)传递参数类型的原理及应用

原创文章转载请注明出处

最近阅读Martini的源码，读到了inject这部分，inject在Martini的代码中无处不在，是Martini框架的绝对核心。

先看看injector类型的声明：

type injector struct {
values map[reflect.Type]reflect.Value
parent Injector
}


撇开 parent不看，values是一个映射表，用于保存注入的参数，它是一个用reflect.Type当键、reflect.Value为值的map。

parent Injector又是什么鬼？

// Injector represents an interface for mapping and injecting dependencies into structs
// and function arguments.
type Injector interface {
Applicator
Invoker
TypeMapper
// SetParent sets the parent of the injector. If the injector cannot find a
// dependency in its Type map it will check its parent before returning an
// error.
SetParent(Injector)
}
// Applicator represents an interface for mapping dependencies to a struct.
type Applicator interface {
// Maps dependencies in the Type map to each field in the struct
// that is tagged with 'inject'. Returns an error if the injection
// fails.
Apply(interface{}) error
}
// Invoker represents an interface for calling functions via reflection.
type Invoker interface {
// Invoke attempts to call the interface{} provided as a function,
// providing dependencies for function arguments based on Type. Returns
// a slice of reflect.Value representing the returned values of the function.
// Returns an error if the injection fails.
Invoke(interface{}) ([]reflect.Value, error)
}
// TypeMapper represents an interface for mapping interface{} values based on type.
type TypeMapper interface {
// Maps the interface{} value based on its immediate type from reflect.TypeOf.
Map(interface{}) TypeMapper
// Maps the interface{} value based on the pointer of an Interface provided.
// This is really only useful for mapping a value as an interface, as interfaces
// cannot at this time be referenced directly without a pointer.
MapTo(interface{}, interface{}) TypeMapper
// Provides a possibility to directly insert a mapping based on type and value.
// This makes it possible to directly map type arguments not possible to instantiate
// with reflect like unidirectional channels.
Set(reflect.Type, reflect.Value) TypeMapper
// Returns the Value that is mapped to the current type. Returns a zeroed Value if
// the Type has not been mapped.
Get(reflect.Type) reflect.Value
}


Injector是注入接口声明的组合，我们先关注TypeMapper这个接口，从源码可以得知Map和MapTo是用来映射数据类型和数据到values map[reflect.Type]reflect.Value的方法。

Map方法相对来说比较简单，利用反射获取对象的type。

func (i *injector) Map(val interface{}) TypeMapper {
i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
return i
}


现在我们先假设参数中有多个string时，values map[reflect.Type]reflect.Value这个map只会保存最后一个string的映射，那我们该如何处理才能完整的保存所有的string参数呢？

考虑interface类型在底层的实现(type,data)，inject库实现了一个从interface指针中获取类型的函数InterfaceOf，而MapTo则利用InterfaceOf来获取传入的数据类型。

func InterfaceOf(value interface{}) reflect.Type {
t := reflect.TypeOf(value)
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
if t.Kind() != reflect.Interface {
panic("Called inject.InterfaceOf with a value that is not a pointer to an interface. (*MyInterface)(nil)")
}
return t
}
func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
i.values[InterfaceOf(ifacePtr)] = reflect.ValueOf(val)
return i
}


简直是神来之笔，再找个别人的例子：

package main
import (
"fmt"
"github.com/codegangsta/inject"
)
type SpecialString interface{}
func main() {
fmt.Println(inject.InterfaceOf((*interface{})(nil)))
fmt.Println(inject.InterfaceOf((*SpecialString)(nil)))
}


输出

interface {}
main.SpecialString


看到了吗？指向接口的空指针，虽然data是nil，但是我们只要它的type。分步解释一下：

//以(*SpecialString)(nil)为例
t := reflect.TypeOf(value) //t是*main.SpecialString，t.Kind()是ptr,t.Elem()是main.SpecialString
for t.Kind() == reflect.Ptr { //循环判断，也许是指向指针的指针
t = t.Elem() //Elem returns a type's element type.
}
if t.Kind() != reflect.Interface {
... //如果不是Interface类型，报panic
}
return t //返回(*SpecialString)(nil)的元素原始类型


interface{}是什么，在go里面interface{}就是万能的Any。inject利用了(*interface{})(nil)携带数据类型的特点，只用一个空指针就搞定了数据类型的传输，而且扩展了同类型数据的绑定。

让我们到martini.go去看看这个注入是怎么用的吧。

// Martini represents the top level web application. inject.Injector methods can be invoked to map services on a global level.
type Martini struct {
inject.Injector
handlers []Handler
action Handler
logger *log.Logger
}
// New creates a bare bones Martini instance. Use this method if you want to have full control over the middleware that is used.
func New() *Martini {
m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(os.Stdout, "[martini] ", 0)}
m.Map(m.logger)
m.Map(defaultReturnHandler())
return m
}
func (m *Martini) createContext(res http.ResponseWriter, req *http.Request) *context {
c := &context{inject.New(), m.handlers, m.action, NewResponseWriter(res), 0}
c.SetParent(m)
c.MapTo(c, (*Context)(nil))
c.MapTo(c.rw, (*http.ResponseWriter)(nil))
c.Map(req)
return c
}


自定义的Martini结构体包含了inject.Injector接口，所以可以很方便的注入logger。后续Invoke中间件的时候，自然就可以通过Injector的Get方法获取logger对象。context则使用了MapTo方法注入了Context和http.ResponseWriter这两个接口类型。

那么Invoke的时候又是如何调用函数并且注入参数的呢？请移步《Invoke如何动态传参》

我是咕咕鸡，一个还在不停学习的全栈工程师。
热爱生活，喜欢跑步，家庭是我不断向前进步的动力。