go 依赖注入与控制反转

简介依赖注入与控制反转

控制反转

正常情况下,对函数或方法的调用是调用方主动直接的行为,调用方清楚的知道被调用的函数名、参数类型,直接主动调用;包括对象的初始化也是显式的直接初始化;控制反转就是将这种行为变成间接行为,主调方不是直接调用函数或对象,而是使用框架代码间接的调用或初始化,这种行为成为"控制反转",控制反转可以解耦合调用方与被调用方,使用框架的程序常常由框架驱动整个程序,在框架下写的业务代码是被框架驱动的,这种模式就是"控制反转"

依赖注入

"依赖注入"是实现"控制反转"的一种方法,如果说"控制反转"是一种设计思想,那"依赖注入"是就是这种思想的一种实现,通过注入参数或实例的方式实现控制反转

inject 框架的依赖注入

inject 演练

1.对函数的注入调用

使用 map 实现一个字符串到函数的映射,map 中的 Value 类型被写成 func(),不同的参数与返回值的类型的函数不能通用,因此将 map 的 Value 定义为 interface{} 空接口类型,使用类型断言与反射来实现,

type s1 interface{}

func Format(name string, level s1) {
   fmt.Printf("name=%s,level=%s", name, level)
}

func main() {
  // 控制实例创建
   ijt := inject.New()
  
  // 实参注入
   ijt.Map("lucy")
   ijt.MapTo("t4", (*s1)(nil))
  
  // 函数反转调用
   ijt.Invoke(Format)
}

/* 执行输出:
name=lucy,level=t4
Process finished with exit code 0
*/

inject 提供了一种注入参数调用函数的通用功能,inject 相当于创建了一个控制实例,用来实现对函数的注入调用;

2.对 struct 的注入调用

type S1 interface{}

type User struct {
   Name  string `inject`
   Level S1     `inject`
}

func main() {
   // 创建被注入的实例
   u := User{}
   
   // 创建控制实例
   ijt := inject.New()

   // 初始化注入值
   ijt.Map("lucy")
   ijt.MapTo("t4", (*S1)(nil))
   
   // 实现对 struct 注入
   _ = ijt.Apply(&u)

   fmt.Printf("u=%v\n", u)
}
/* 执行输出:
u={lucy t4}
Process finished with exit code 0  
*/

inject 提供对结构体类型的通用注入方法

inject原理解析

入口函数New

injectNew() 函数构建一个具体类型的实例作为内部注入引擎,返回一个 Injector 类型的接口,面向接口设计的思想,对外暴露接口方法隐藏内部实现:

func New() Injector {
   return &injector{
      values: make(map[reflect.Type]reflect.Value),
   }
}

接口设计

Injector 暴露所有方法给外部调用者,这些方法可归为两大类:

  • 第一类对参数注入进行初始化,将结构类型的字段的注入与函数的参数的注入统一一套方法实现
  • 第二类专用注入实现,分别是生成结构对象与调用函数方法

inject 将多个接口组合为一个大接口,符合 go 的 Duck 类型接口设计原则,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)
}
TypeMapper

接口实现对注入参数操作的汇总,包括设置与查找相关参数的类型、值的方法,函数的实参与结构体的字段,在 inject 内部放在 map[reflect.Type]reflect.Value 类型的 map 中,代码如下:

// 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
}
Invoker

Invoker 方法是调用被注入实参的函数

// 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)
}
Applicator

Applicator 接口中 Apply 方法实现对结构体的注入

// 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
}
inject 处理流程:
  1. 通过 inject.New() 创建注入引擎,返回 Injector 接口类型变量
  2. 调用 TypeMapper 接口(Injector 内的 TypeMapper)的方法注入 struct 字段值或函数的是实参值
  3. 调用 Invoke 方法执行被注入的函数,或调用 Applicator 接口方法获得被注入后的结构实例

内部实现

inject 内部的注入引擎 injector 的实现

injector 对 struct 注入实现
type injector struct {
   values map[reflect.Type]reflect.Value
   parent Injector
}

values 中存放的被注入 struct 的字段类型与值或函数实参的类型与值;values 是以 reflect.Type 为 Key 的 map ,如果一个结构体的字段类型相同,后注入大参数会覆盖前面的参数,规避的办法是使用 MapTo 方法,通过抽象出一个接口类型来避免覆盖

func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
   i.values[InterfaceOf(ifacePtr)] = reflect.ValueOf(val)
   return i
}
injector 对函数注入实现
// 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.
// It panics if f is not a function
func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
   // 获取函数类型的 Type
   t := reflect.TypeOf(f)

   // 构造一个存放函数实参 Value 值的数组
   var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func
  
   // 使用反射获取函数的实参 reflect.Type 逐个去 injector 中查找注入 Value 值
   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
}

facebook 的 inject

通过创建与连接各种对象来解耦组件之间的依赖关系,避免手动配置每个组件的依赖关系

type RedisDB struct {
    Name string
    Adds string
}

type App struct {
    Name  string
    Redis *RedisDB `inject:""`
}

func (a *App) Create() string {
    return "create app in db name:" + a.Redis.Name + "[" + a.Redis.Adds + "]" + "app name:" + a.Name
}

type AppObject struct {
    App *App
}

func Init() *AppObject {
    db := RedisDB{
        Name: "redis",
        Adds: "192.168.1.1"}

    app := App{Name: "go-app"}

    var g inject.Graph

    _ = g.Provide(
        &inject.Object{Value: &app},
        &inject.Object{Value: &db},
    )
    _ = g.Populate()

    return &AppObject{
        App: &app,
    }

}

func main() {
    obj := Init()
    fmt.Println(obj.App.Create())
}
/*执行输出:
create app in db name:redis[192.168.1.1] app name :go-app

Process finished with exit code 0
*/

Populate 函数

// Populate is a short-hand for populating a graph with the given incomplete
// object values.
func Populate(values ...interface{}) error {
    var g Graph
    for _, v := range values {
        if err := g.Provide(&Object{Value: v}); err != nil {
            return err
        }
    }
    return g.Populate()
}

Populate方法使用给定的不完整对象值填补对象图形,简单的手段填充

Graph 对象

// The Graph of Objects.
type Graph struct {
    Logger      Logger // Optional, will trigger debug logging.
    unnamed     []*Object
    unnamedType map[reflect.Type]bool
    named       map[string]*Object
}

Graph 包含以下方法:

  • Objects
  • Populate
  • Provide

Objects

对象返回所有已知对象,命名以及未命名

Populate

填充不完整的对象

Provide

向Graph提供对象

Logger 对象

type Logger interface {
    Debugf(format string, v ...interface{})
}

记录简单的日志

Object 对象

// An Object in the Graph.
type Object struct {
    Value        interface{}
    Name         string             // Optional
    Complete     bool               // If true, the Value will be considered complete
    Fields       map[string]*Object // Populated with the field names that were injected and their corresponding *Object.
    reflectType  reflect.Type
    reflectValue reflect.Value
    private      bool // If true, the Value will not be used and will only be populated
    created      bool // If true, the Object was created by us
    embedded     bool // If true, the Object is an embedded struct provided internally
}

Graph 中的对象,每个注入对象对应 Object,通过 Object 完成

你可能感兴趣的:(go 依赖注入与控制反转)