Golang 反射实现依赖注入

Coding/Golang #Golang #Golang/reflect

依赖注入

本人因为Java转入Golang就会带入一些Java的思维，依赖注入是个好东西，概念不多缀述。

构想

• 创建包含要注入对象的实例，并存入一个Map
• 创建需要被别的对象注入的对象实例，也存入这个Map
• 对象注册完成后，调用Inject方法，Inject会遍历整个Map，找出对象中所有要注入的属性，找出并注入

结构体改造前的代码

func main(){
    runner := &Runner{}
    eater := &Eater{}
    people := NewPeople(runner, eater)
    people.Run.Run()
}
func NewPeople(run IRun, eat IEat) IPeople {
    return & People{
        Run: run,
        Eat: eat,
    }
}
type People struct {
    Run IRun
    Eat IEat
}

结构体改造后的代码

func main(){
    core.register("run", &Runner{}) //以run为名注册 Runner
    core.register("eat", &Eater{}) //以eat为名注册 Eater
    people := &People{}
    core.autoRegister(people) //以*main.People为名注册 People
    core.inject() //注入带有Tag:"auto"的所有对象
    people.Run.Run()
}
type People struct {
    Run IRun `auto:"run"`
    Eat IEat `auto:"eat"`
}

实现

Tag

使用Tag auto标记出需要自动注入的对象，如： auto:"run"取出以run名注册的对象并注入。
遍历字段找出所有Tag为auto的字段。

value := reflect.ValueOf(obj)
if value.Kind() == reflect.Ptr {
    value = value.Elem()
}
for i := 0; i < value.NumField(); i++ {
    name := value.Type().Field(i).Tag.Get("auto")
    // 获取到tag auto 的值
}

反射注入

在这里给一个Public属性修改值比较简单：

field := value.Field(i) // 获取字段
field.Set(value) // 设置值

但是当值是个Private时，调用Set会发生Panic，可以使用方法CanSet判断出来，主要问题还是如何为一个Private对象设置值：

field := value.Field(i)
field = reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())).Elem()
field.Set(value)

这些都是标准库中的方法，没有存在很花哨的东西。

附录

import (
    "fmt"
    "reflect"
    "unsafe"
)

const (
    InjectorTag = "auto"
)

var objs map[string]reflect.Value

func init() {
    objs = make(map[string]reflect.Value, 10)
}

// Register 注册对象
func Register(name string, v interface{}) {
    objs[name] = reflect.ValueOf(v)
}

// AutoRegister 注册对象
func AutoRegister(v interface{}) {
    rv := reflect.ValueOf(v)
    Register(rv.Type().String(), rv)
}

// Get 获取注册对象
func Get(key string) interface{} {
    v, ok := objs[key]
    if ok {
        return v.Interface()
    }
    return nil
}

// Remove 删除注册对象
func Remove(key string) {
    delete(objs, key)
}

func Inject() {
    for _, v := range objs {
        value := v
        if value.Kind() == reflect.Ptr {
            value = value.Elem()
        }
        for i := 0; i < value.NumField(); i++ {
            name := value.Type().Field(i).Tag.Get(InjectorTag)
            temp, ok := objs[name]
            if ok {
                field := value.Field(i)
                if field.CanSet() {
                    field.Set(temp)
                } else {
                    field = reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())).Elem()
                    field.Set(temp)
                }
            }
        }
    }
}