Go——Inject库

骑猪看日落 2023-10-09 21:36 16阅读 0赞

### 1.、依赖注入和控制反转 ###

在介绍inject之前先简单介绍“依赖注入”和“控制反转”的概念。正常情况下，对函数或方法的调用是调用方的主动直接行为，调用方清楚地知道被调的函数名是什么，参数有哪些类型，直接主动地调用：包括对象的初始化也是显式地直接初始化。所谓的“控制反转”就是将这种主动行为变成间接的行为，主调方不是直接调用函数或对象，而是借助框架代码进行间接的调用和初始化，这种行为我们称为“控制反转”，控制反转可以解耦调用方和被调方。

“库”和“框架”能很好地解释“控制反转”的概念。一般情况下，使用库的程序是程序主动地调用库的功能，但使用框架的程序常常由框架驱动整个程序，在框架下写的业务代码是被框架驱动的，这种模式就是“控制反转”。

“依赖注入”是实现“控制反转”的一种方法，如果说“控制反转”是一种设计思想，那么“依赖注入”就是这种思想的一种实现，通过注入的参数或实例的方式实现控制反转。如果  
没有特殊说明，我们通常说的“依赖注入”和“控制反转”是一个东西。

反转的框架代码读取配置，动态地构建对象，这一点在Java的Spring框架中体现得尤为突出。控制反转是解决复杂问题一种方法，特别是在Wb框架中为路由和中间件的灵活注入提供了很好的方法。但是软件开发没有银弹，当问题足够复杂时，应该考虑的是服务拆分，而不是把复杂的逻辑用一个“大盒子”装起来，看起来干净了，但也只是看起来干净，实现还是很复杂，这也是使用框架带来的副作用。

### 2、inject实践 ###

inject是Go语言依赖注入的实现，它实现了对结构(struct)和函数的依赖注入。在介绍具体实现之前，先来想一个问题，如何通过一个字符串类型的函数名调用函数。Go没有Java中的Class.forName方法可以通过类名直接构造对象，所以这种方法是行不通的，能想到的方法就是使用map实现一个字符串到函数的映射，代码如下：

func f1() {
        
    	println("f1")
    }
    
    func f2() {
        
    	println("f2")
    }
    
    funcs := make(map[string]func())
    funcs["f1"] = f1
    funcs["f2"] = f2
    
    funcs["f1"]()
    funcs["f2"]()

但是这有个缺陷，就是map的Value类型被写成func(),不同参数和返回值的类型的函数并不能通用。将map的Value定义为interface\{\}空接口类型是否能解决该问题？可以解决该  
问题，但需要借助类型断言或反射来实现，通过类型断言实现等于又绕回去了，反射是一种可行的办法。inject包借助反射实现函数的注入调用，下面通过一个例子来看一下。

package main
    
    import "fmt"
    import "github.com/codegangsta/inject"
    
    func main() {
        
    	//控制实例的创建
    	inj := inject.New()
    
    	//实参注入
    	inj.Map("tom")
    	inj.MapTo("tencent", (*S1)(nil))
    	inj.MapTo("T4", (*S2)(nil))
    	inj.Map(23)
    
    	//函数调用
    	inj.Invoke(Format)//name=tom, company=tencent, level=T4, age=23!
    }
    
    type S1 interface{
        }
    type S2 interface{
        }
    
    func Format(name string, company S1, level S2, age int) {
        
    	fmt.Printf("name=%s, company=%s, level=%s, age=%d!\n", name, company, level, age)
    }

可见inject提供了一种注入参数调用函数的通用功能，inject.New()相当于创建了一个控制实例，由其来实现对函数的注入调用。inject包不但提供了对函数的注入，还实现了对struct类型的注入，看下一个示例:

package main
    
    import (
    	"fmt"
    	"github.com/codegangsta/inject"
    )
    
    func main() {
        
    	//创建被注入实例
    	s := Staff{
        }
    
    	inj := inject.New()
    
    	//初始化注入值
    	inj.Map("tom")
    	inj.MapTo("tencent", (*S1)(nil))
    	inj.MapTo("T4", (*S2)(nil))
    	inj.Map(23)
    
    	//实现对struct注入
    	inj.Apply(&s)
    
    	fmt.Printf("s=%v\n", s)//s={tom tencent T4 23}
    }
    
    type S1 interface {
        
    }
    
    type S2 interface {
        
    }
    
    type Staff struct {
        
    	Name    string `inject`
    	Company S1     `inject`
    	Level   S2     `inject`
    	Age     int    `inject`
    }

### inject原理分析 ###

##### 入口函数New #####

inject…NewO函数构建一个具体类型injector实例作为内部注入引擎，返回的是一个Injector类型的接口。这里也体现了一种面向接口的设计思想：对外暴露接口方法，对外隐藏内部实现。  
示例如下：

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

##### 接口设计 #####

下面来看一下具体的接口设计，Injector暴露了所有方法给外部使用者，这些方法又可以归纳为两大类。第一类方法是对参数注入进行初始化，将结构类型的字段的注入和函数的参数注入统一成一套方法实现；第二类是专用注入实现，分别是生成结构对象和调用函数方法。

在代码设计上，inject将接口的粒度拆分得很细，将多个接口组合为一个大的接口，这也符合Go的Duck类型接口设计的原则。Injector按照上述方法拆分为三个接口。示例如下：

type Injector interface {
        
    	//抽象生成注入结构实例的接口
    	Applicator
    
    	//抽象函数调用的接口
    	Invoker
    
    	//抽象注入参数的接口
    	TypeMapper
    	
    	//实现一个注入实例链，下游的能覆盖上游的类型
    	SetParent(Injector)
    }

TypeMapper接口实现对注入参数操作的汇总，包括设置和查找相关的类型和值的方法。注意：无论函数的实参，还是结构的字段，在inject内部，都存放map\[reflect.Type\]reflect.Value类型的map里面，具体实现在后面介绍injector时会讲解。

type TypeMapper interface {
        
    	//如下三个方法是设置参数
    	Map(interface{
        }) TypeMapper
    	MapTo(interface{
        }, interface{
        }) TypeMapper
    	Set(reflect.Type, reflect.Value) TypeMapper
    
    	//查找参数
    	Get(reflect.Type) reflect.Value
    }

Invoker接口中Invoke方法是对被注入实参函数的调用：

type Invoker interface {
        
    	Invoke(interface(})([]reflect.Value,error)
    }

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

type Applicator interface {
        
    	Apply(interface())error
    }

梳理整个inject包的处理流程：

1.  通过inject.New()创建注入引擎，注入引擎被隐藏，返回的是Injector接口类型变量。
2.  调用TypeMapper接口(Injector内嵌TypeMapper)的方法注入struct的字段值或函数的实参值。
3.  调用Invoker方法执行被注入的函数，或者调用Applicator接口方法获得被注入后的结构实例。

##### 内部实现 #####

下面具体看一下inject内部注入引擎injector的实现，首先看一下injector的数据结构。

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里面的parent的作用是实现多个注入引擎，其构成了一个链。  
下面重点分析injector对函数的注入实现。示例如下：

func (inj *injector) Invoke(f interface{
        }) ([]reflect.Value, error) {
        
    	//获取函数类型的Type
    	t := reflect.TypeOf(f)
    
    	//构造一个存放函数实参Value值的数组
    	var in = make([]reflect.Value, t.NumIn()) 
    
    	//使用反射获取函数实参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
    }

inject对函数注入调用实现很简洁，就是从injector里面获取函数实参，然后调用函数。通过对inject包的分析，认识到其“短小精悍”、功能强大，这些实现的基础是依靠反射。  
但同时注意到包含反射的代码相对来说复杂难懂，虽然inject的实现只有短短200行代码，但阅读起来并不是很流畅。所以说反射是一把双刃剑，好用但代码不好读。