关于依赖注入

依赖注入（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("[email protected]")
  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 函数指针。而这种用法，也完全反应了 “反射”模块 的功能强大：完全不用管 参数的各种类型，用一个方法来实现各种参数类型的调用 (多态)， 就象动态语言一样。