依赖注入(Depen)是一种减少代码组件耦合度的设计思想。
一般减少代码耦合度的代码设计师分层,分模块。在此基础上,如果在不同层、不同模块内部直接调用其他层或者模块的实例或者方法,这样又引入了耦合。因此我们应该通过将其他层(模块)的实例或者方法注入(参数传递)的方式实现对其他实例的调用。
在面向对象语言编程中,可以这么理解:不是在宿主(调用方)内部直接通过new实例化另一个类的实例来调用成员或者方法,而是通过在构造函数中注入依赖(被调用方),然后在调用依赖。
在弱类型语言中,写接口的时候不需要提前定义参数的类型。但是在强类型语言中,接口的定义中已经包含了参数类型,这也就限定了注入依赖的类型。因此,在强类型语言中,要实现依赖注入,我们要需要一个注入器(Injector),注入器的作用就是让接口在定义时,可以不考虑传入的依赖的类型,依赖通过注入器注入注入到宿主内部。
下面是一段网上找的实现注入器的程序:
在Host中,只能拿到依赖方法的参数类型,而我们需要将参数类型和参数值建立联系,因此,在Injector中封装一个map[Type]Value
是自然而然的选择。
package main
import (
"fmt"
"reflect"
)
type Injector struct {
mappers map[reflect.Type]reflect.Value // 根据类型map实际的值
}
func (inj *Injector) SetMap(value interface{}) {
inj.mappers[reflect.TypeOf(value)] = reflect.ValueOf(value)
}
func (inj *Injector) Get(t reflect.Type) reflect.Value {
return inj.mappers[t]
}
func (inj *Injector) Invoke(i interface{}) []reflect.Value {
t := reflect.TypeOf(i)
if t.Kind() != reflect.Func {
panic("Should invoke a function!")
}
inValues := make([]reflect.Value, t.NumIn())
for k := 0; k < t.NumIn(); k++ {
inValues[k] = inj.Get(t.In(k))
}
ret := reflect.ValueOf(i).Call(inValues)
return ret
}
func Host(name string, f func(a int, b string)) {
fmt.Println("Enter Host:", name)
inj.Invoke(f) // 利用注入器中的环境调用f
// 这种使用方法,看起来就像把自定义的方法f里的执行语句放在Host中执行一样自然
// 语句从f里穿透到Host方法中,这就是注入一词的由来。
fmt.Println("Exit Host:", name)
}
func Dependency(a int, b string) {
fmt.Println("Dependency: ", a, b)
}
var inj *Injector // 全局的注入器,保存注入环境
func main() {
// 创建注入器
inj = &Injector{make(map[reflect.Type]reflect.Value)}
inj.SetMap(3030)
inj.SetMap("zdd")
d := Dependency
Host("zddhub", d)
inj.SetMap(8080)
inj.SetMap("www.zddhub.com")
Host("website", d)
}
稍微改进一下我们的注入器,让它更通用些。
package main
import (
"fmt"
"reflect"
)
type Injector struct {
mappers map[reflect.Type]reflect.Value // 根据类型map实际的值
}
func (inj *Injector) SetMap(value interface{}) {
inj.mappers[reflect.TypeOf(value)] = reflect.ValueOf(value)
}
func (inj *Injector) Get(t reflect.Type) reflect.Value {
return inj.mappers[t]
}
func (inj *Injector) Invoke(i interface{}) []reflect.Value {
t := reflect.TypeOf(i)
if t.Kind() != reflect.Func {
panic("Should invoke a function!")
}
inValues := make([]reflect.Value, t.NumIn())
for k := 0; k < t.NumIn(); k++ {
inValues[k] = inj.Get(t.In(k))
}
ret := reflect.ValueOf(i).Call(inValues)
return ret
}
func New() *Injector {
return &Injector{make(map[reflect.Type]reflect.Value)}
}
func Host(name string, i interface{}) { // 让注入的方法不受限制
inj.Invoke(i) // 利用注入器中的环境调用f
}
func Dependency(a int, b string) {
fmt.Println("Dependency: ", a, b)
}
var inj *Injector
func main() {
inj = New()
inj.SetMap(3030)
inj.SetMap("zdd")
d := Dependency
Host("zddhub", d)
inj.SetMap(8080)
inj.SetMap("zddhub@gmail.com")
inj.SetMap(10.24)
Host("email", func(email string, money float64, number int) {
fmt.Println(email, money, number)
})
Host("Get", func() {
fmt.Println("Hello world!")
})
}
第一步是往host里注入(传入)依赖(函数指针),其实是“注入依赖函数”;第二步是host内部调用依赖(函数指针)时传参数,其实是“往依赖函数中注入参数”;所谓 “依赖注入器”就是:1)先按照顺序,将 “依赖函数的参数” 逐个“压入”到“依赖注入器”;2)将“依赖注入器”注入 到 host 时“依赖注入器”将上面的参数逐个“弹出”注入到依赖函数里执行。 这和用 汇编代码调用 WindowsAPI函数的过程很象:先从左到右逐个参数压栈,然后CALL 函数指针。而这种用法,也完全反应了 “反射”模块 的功能强大:完全不用管 参数的各种类型,用一个方法来实现各种参数类型的调用 (多态), 就象动态语言一样。