博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
golang: Martini之inject源码分析
阅读量:6567 次
发布时间:2019-06-24

本文共 7494 字,大约阅读时间需要 24 分钟。

  hot3.png

依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。在传统的程序设计过程中,调用者是自己来决定使用哪些被调用者实现的。但是在依赖注入模式中,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者实例的工作通常由注入器来完成,然后注入调用者,因此也称为依赖注入。

 是依赖注入的golang实现,作者是  。它能在运行时注入参数,调用方法。是Martini框架的基础核心。

我对依赖注入提取了以下2点性质:

  1. 由注入器注入属性。

  2. 由注入器创建被调用者实例。

在inject中,被调用者为func,因此注入属性也即对func注入实参(当然inject也可以注入struct,这样的话注入的属性就是struct中的已添加tag为`inject`的导出字段)。我们来看下普通的函数调用:

package mainimport (	"fmt")func Say(name, gender string, age int) {	fmt.Printf("My name is %s, gender is %s, age is %d!\n", name, gender, age)}func main() {	Say("陈一回", "男", 20)}

上面的例子中,定义了函数Say并在main方法中手动调用。这样总是可行的,但是有时候我们不得不面对这样一种情况:比如在web开发中,我们注册路由,服务器接受请求,然后根据request path调用相应的handler。这个handler必然不是由我们手动来调用的,而是由服务器端根据路由匹配来查找对应的handler并自动调用。

是时候引入inject了,尝试用inject改写上面的代码:

package mainimport (	"fmt"	"github.com/codegangsta/inject")type SpecialString interface{}func Say(name string, gender SpecialString, age int) {	fmt.Printf("My name is %s, gender is %s, age is %d!\n", name, gender, age)}func main() {	inj := inject.New()	inj.Map("陈一回")	inj.MapTo("男", (*SpecialString)(nil))	inj.Map(20)	inj.Invoke(Say)}

$ cd $GOPATH/src/injector_test$ go build$ ./injector_testMy name is 陈一回, gender is 男, age is 20!

看不懂?没关系,因为我们对于inject还没有足够的知识储备,一切从分析inject的源码开始。

inject包只有2个文件,一个是inject.go文件,还有一个是inject_test.go,但我们只关注inject.go文件。

inject.go短小精悍,包括注释和空行才157行。定义了4个接口,包括一个父接口和三个子接口,接下来您就会知道这样定义的好处了。

为了方便,我把所有的注释都去掉了:

type Injector interface {	Applicator	Invoker	TypeMapper	SetParent(Injector)}type Applicator interface {	Apply(interface{}) error}type Invoker interface {	Invoke(interface{}) ([]reflect.Value, error)}type TypeMapper interface {	Map(interface{}) TypeMapper	MapTo(interface{}, interface{}) TypeMapper	Get(reflect.Type) reflect.Value}

接口Injector是接口Applicator、接口Invoker、接口TypeMapper的父接口,所以实现了Injector接口的类型,也必然实现了Applicator接口、Invoker接口和TypeMapper接口。

Applicator接口只规定了Apply成员,它用于注入struct。

Invoker接口只规定了Invoke成员,它用于执行被调用者。

TypeMapper接口规定了三个成员,Map和MapTo都用于注入参数,但它们有不同的用法。Get用于调用时获取被注入的参数。

另外Injector还规定了SetParent行为,它用于设置父Injector,其实它相当于查找继承。也即通过Get方法在获取被注入参数时会一直追溯到parent,这是个递归过程,直到查找到参数或为nil终止。

type injector struct {	values map[reflect.Type]reflect.Value	parent Injector}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 New() Injector {	return &injector{		values: make(map[reflect.Type]reflect.Value),	}}

injector是inject包中唯一定义的struct,所有的操作都是基于injector struct来进行的。它有两个成员values和parent。values用于保存注入的参数,它是一个用reflect.Type当键、reflect.Value为值的map,这个很重要,理解这点将有助于理解Map和MapTo。New方法用于初始化injector struct,并返回一个指向injector struct的指针。但是请注意这个返回值被Injector接口包装了。

InterfaceOf方法虽然只有几句实现代码,但它是Injector的核心。InterfaceOf方法的参数必须是一个接口类型的指针,如果不是则引发panic。InterfaceOf方法的返回类型是reflect.Type,您应该还记得injector的成员values就是一个reflect.Type类型当键的map。这个方法的作用其实只是获取参数的类型,而不关心它的值。我之前有篇文章介绍过(*interface{})(nil),感兴趣的朋友可以去看看: 。

为了加深理解,来举个例子:

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

$ cd $GOPATH/src/injector_test$ go build$ ./injector_testinterface {}main.SpecialString

上面的输出一点也不奇怪。InterfaceOf方法就是用来得到参数类型,而不关心它具体存储的是什么值。值得一提的是,我们定义了一个SpecialString接口。我们在之前的代码也有定义SpecialString接口,用在Say方法的参数声明中,之后您就会知道为什么要这么做。当然您不一定非得命名为SpecialString。

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) Get(t reflect.Type) reflect.Value {	val := i.values[t]	if !val.IsValid() && i.parent != nil {		val = i.parent.Get(t)	}	return val}func (i *injector) SetParent(parent Injector) {	i.parent = parent}

Map和MapTo方法都用于注入参数,保存于injector的成员values中。这两个方法的功能完全相同,唯一的区别就是Map方法用参数值本身的类型当键,而MapTo方法有一个额外的参数可以指定特定的类型当键。但是MapTo方法的第二个参数ifacePtr必须是接口指针类型,因为最终ifacePtr会作为InterfaceOf方法的参数。

为什么需要有MapTo方法?因为注入的参数是存储在一个以类型为键的map中,可想而知,当一个函数中有一个以上的参数的类型是一样时,后执行Map进行注入的参数将会覆盖前一个通过Map注入的参数。

SetParent方法用于给某个Injector指定父Injector。Get方法通过reflect.Type从injector的values成员中取出对应的值,它可能会检查是否设置了parent,直到找到或返回无效的值,最后Get方法的返回值会经过IsValid方法的校验。举个例子来加深理解:

package mainimport (	"fmt"	"github.com/codegangsta/inject"	"reflect")type SpecialString interface{}func main() {	inj := inject.New()	inj.Map("陈一回")	inj.MapTo("男", (*SpecialString)(nil))	inj.Map(20)	fmt.Println("string is valid?", inj.Get(reflect.TypeOf("姓陈名一回")).IsValid())	fmt.Println("SpecialString is valid?", inj.Get(inject.InterfaceOf((*SpecialString)(nil))).IsValid())	fmt.Println("int is valid?", inj.Get(reflect.TypeOf(18)).IsValid())	fmt.Println("[]byte is valid?", inj.Get(reflect.TypeOf([]byte("Golang"))).IsValid())	inj2 := inject.New()	inj2.Map([]byte("test"))	inj.SetParent(inj2)	fmt.Println("[]byte is valid?", inj.Get(reflect.TypeOf([]byte("Golang"))).IsValid())}

$ cd $GOPATH/src/injector_test$ go build$ ./injector_teststring is valid? trueSpecialString is valid? trueint is valid? true[]byte is valid? false[]byte is valid? true

通过以上例子应该知道SetParent是什么样的行为。是不是很像面向对象中的查找链?

func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {	t := reflect.TypeOf(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	}	return reflect.ValueOf(f).Call(in), nil}

Invoke方法用于动态执行函数,当然执行前可以通过Map或MapTo来注入参数,因为通过Invoke执行的函数会取出已注入的参数,然后通过reflect包中的Call方法来调用。Invoke接收的参数f是一个接口类型,但是f的底层类型必须为func,否则会panic。

package mainimport (	"fmt"	"github.com/codegangsta/inject")type SpecialString interface{}func Say(name string, gender SpecialString, age int) {	fmt.Printf("My name is %s, gender is %s, age is %d!\n", name, gender, age)}func main() {	inj := inject.New()	inj.Map("陈一回")	inj.MapTo("男", (*SpecialString)(nil))	inj2 := inject.New()	inj2.Map(20)	inj.SetParent(inj2)	inj.Invoke(Say)}

上面的例子如果没有定义SpecialString接口作为gender参数的类型,而把name和gender都定义为string类型,那么gender会覆盖name的值。如果您还没有明白,建议您把这篇文章从头到尾再看几遍。

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	}	t := v.Type()	for i := 0; i < v.NumField(); i++ {		f := v.Field(i)		structField := t.Field(i)		if f.CanSet() && structField.Tag == "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}

Apply方法是用于对struct的字段进行注入,参数为指向底层类型为结构体的指针。可注入的前提是:字段必须是导出的(也即字段名以大写字母开头),并且此字段的tag设置为`inject`。以例子来说明:

package mainimport (	"fmt"	"github.com/codegangsta/inject")type SpecialString interface{}type TestStruct struct {	Name   string `inject`	Nick   []byte	Gender SpecialString `inject`	uid    int           `inject`	Age    int           `inject`}func main() {	s := TestStruct{}	inj := inject.New()	inj.Map("陈一回")	inj.MapTo("男", (*SpecialString)(nil))	inj2 := inject.New()	inj2.Map(20)	inj.SetParent(inj2)	inj.Apply(&s)	fmt.Println("s.Name =", s.Name)	fmt.Println("s.Gender =", s.Gender)	fmt.Println("s.Age =", s.Age)}

$ cd $GOPATH/src/injector_test$ go build$ ./injector_tests.Name = 陈一回s.Gender = 男s.Age = 20

刑星写了一篇博文可供参考: ,建议大家都去看下。

转载于:https://my.oschina.net/goal/blog/195036

你可能感兴趣的文章
【Python】轻量级分布式任务调度系统-RQ
查看>>
写在2016年头
查看>>
[20150113]关于oracle的存储结构.txt
查看>>
orion的简单测试
查看>>
Word中向左缩进
查看>>
MySQL 5.7 SYS SCHEMA
查看>>
SM$TS_USED,SM$TS_FREE,SM$TS_AVAIL
查看>>
[20150710]11G谓词推入问题2.txt
查看>>
20170401 11G Deprecated Attributes for LOG_ARCHIVE_DEST_n
查看>>
查看apache、linux、kernel、nginx等版本
查看>>
没想到,阿里工程师每天必刷的网站是......
查看>>
chrome使用技巧(看了定不让你失望)
查看>>
Eclipse和PyDev搭建完美Python开发环境(Windows篇)(转)
查看>>
基于纯Java代码的Spring容器和Web容器零配置的思考和实现(3) - 使用配置
查看>>
mybatis做like模糊查询
查看>>
HDOJ 1214 圆桌会议
查看>>
很多人都在埋怨没有遇到好的团队,但好的团队不可能凭空出现,一流的团队不能仅靠团队成员努力,作为Leader,要有可行的规划,并坚定地执行、时势地调整(转)...
查看>>
分布式缓存系统Memcached简介与实践(.NET memcached client library)
查看>>
html5 图片上传,支持图片预览、压缩、及进度显示,兼容IE6+及标准浏览器
查看>>
你真的会玩SQL吗?Case的用法(转)
查看>>