golang不到30行代码实现依赖注入的方法

　　本文介绍了golang不到30行代码实现依赖注入的方法，分享给大家，具体如下：

　　项目地址

　　go-di-demo

　　本项目依赖

　　使用标准库实现，无额外依赖

　　依赖注入的优势

　　用java的人对于spring框架一定不会陌生，spring核心就是一个IoC(控制反转/依赖注入)容器，带来一个很大的优势是解耦。一般只依赖容器，而不依赖具体的类，当你的类有修改时，最多需要改动一下容器相关代码，业务代码并不受影响。

　　golang的依赖注入原理

　　总的来说和java的差不多，步骤如下：(golang不支持动态创建对象，所以需要先手动创建对象然后注入，java可以直接动态创建对象)

　　 通过反射读取对象的依赖(golang是通过tag实现) 在容器中查找有无该对象实例 如果有该对象实例或者创建对象的工厂方法，则注入对象或使用工厂创建对象并注入 如果无该对象实例，则报错

　　代码实现

　　一个典型的容器实现如下，依赖类型参考了spring的singleton/prototype，分别对象单例对象和实例对象:

　　 package di import ( sync reflect fmt strings errors ) var ( ErrFactoryNotFound = errors.New(factory not found) ) type factory = func() (interface{}, error) // 容器 type Container struct { sync.Mutex singletons map[string]interface{} factories map[string]factory } // 容器实例化 func NewContainer() *Container { return &Container{ singletons: make(map[string]interface{}), factories: make(map[string]factory), } } // 注册单例对象 func (p *Container) SetSingleton(name string, singleton interface{}) { p.Lock() p.singletons[name] = singleton p.Unlock() } // 获取单例对象 func (p *Container) GetSingleton(name string) interface{} { return p.singletons[name] } // 获取实例对象 func (p *Container) GetPrototype(name string) (interface{}, error) { factory, ok := p.factories[name] if !ok { return nil, ErrFactoryNotFound } return factory() } // 设置实例对象工厂 func (p *Container) SetPrototype(name string, factory factory) { p.Lock() p.factories[name] = factory p.Unlock() } // 注入依赖 func (p *Container) Ensure(instance interface{}) error { elemType := reflect.TypeOf(instance).Elem() ele := reflect.ValueOf(instance).Elem() for i := 0; i < elemType.NumField(); i++ { // 遍历字段 fieldType := elemType.Field(i) tag := fieldType.Tag.Get(di) // 获取ectName(tag) if diName == { continue } var ( diInstance interface{} err error ) if p.isSingleton(tag) { diInstance = p.GetSingleton(diName) } if p.isPrototype(tag) { diInstance, err = p.GetPrototype(diName) } if err != nil { return err } if diInstance == nil { return errors.New(diName + dependency not found) } ele.Field(i).Set(reflect.ValueOf(diInstance)) } return nil } // 获取需要注入的依赖名称 func (p *Container) injectName(tag string) string { tags := strings.Split(tag, ,) if len(tags) == 0 { return } return tags[0] } // 检测是否单例依赖 func (p *Container) isSingleton(tag string) bool { tags := strings.Split(tag, ,) for _, name := range tags { if name == prototype { return false } } return true } // 检测是否实例依赖 func (p *Container) isPrototype(tag string) bool { tags := strings.Split(tag, ,) for _, name := range tags { if name == prototype { return true } } return false } // 打印容器内部实例 func (p *Container) String() string { lines := make([]string, 0, len(p.singletons)+len(p.factories)+2) lines = append(lines, singletons:) for name, item := range p.singletons { line := fmt.Sprintf( %s: %x %s, name, &item, reflect.TypeOf(item).String()) lines = append(lines, line) } lines = append(lines, factories:) for name, item := range p.factories { line := fmt.Sprintf( %s: %x %s, name, &item, reflect.TypeOf(item).String()) lines = append(lines, line) } return strings.Join(lines, \n) } 最重要的是Ensure方法，该方法扫描实例的所有export字段，并读取di标签，如果有该标签则启动注入。 判断di标签的类型来确定注入singleton或者prototype对象

　　测试

　　 单例对象在整个容器中只有一个实例，所以不管在何处注入，获取到的指针一定是一样的。 实例对象是通过同一个工厂方法创建的，所以每个实例的指针不可以相同。

　　下面是测试入口代码，完整代码在github仓库，有兴趣的可以翻阅：

　　执行之后打印出来的结果为：

　　db: 0xc4200b6140
db1: 0xc4200b6140
b: 0xc4200a0330
b1: 0xc4200a0338

　　可以看到两个db实例的指针一样，说明是同一个实例，而两个b的指针不同，说明不是一个实例。

　　写在最后

　　通过依赖注入可以很好的管理多个对象之间的实例化以及依赖关系，配合配置文件在应用初始化阶段将需要注入的实例注册到容器中，在应用的任何地方只需要在实例化时注入容器即可。没有额外依赖。

　　以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。