简介依赖注入与控制反转
控制反转
正常情况下,对函数或方法的调用是调用方主动直接的行为,调用方清楚的知道被调用的函数名、参数类型,直接主动调用;包括对象的初始化也是显式的直接初始化;控制反转就是将这种行为变成间接行为,主调方不是直接调用函数或对象,而是使用框架代码间接的调用或初始化,这种行为成为"控制反转",控制反转可以解耦合调用方与被调用方,使用框架的程序常常由框架驱动整个程序,在框架下写的业务代码是被框架驱动的,这种模式就是"控制反转"
依赖注入
"依赖注入"是实现"控制反转"的一种方法,如果说"控制反转"是一种设计思想,那"依赖注入"是就是这种思想的一种实现,通过注入参数或实例的方式实现控制反转
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 处理流程:
- 通过 inject.New() 创建注入引擎,返回 Injector 接口类型变量
- 调用 TypeMapper 接口(Injector 内的 TypeMapper)的方法注入 struct 字段值或函数的是实参值
- 调用 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 完成
