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

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

项目地址

本项目依赖

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

依赖注入的优势

用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") // 获取tag
  diname := p.injectname(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对象

测试

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

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

package main

import (
 "di"
 "database/sql"
 "fmt"
 "os"
 _ "github.com/go-sql-driver/mysql"
 "demo"
)

func main() {
 container := di.newcontainer()
 db, err := sql.open("mysql", "root:root@tcp(localhost)/sampledb")
 if err != nil {
  fmt.printf("error: %s\n", err.error())
  os.exit(1)
 }
 container.setsingleton("db", db)
 container.setprototype("b", func() (interface{}, error) {
  return demo.newb(), nil
 })

 a := demo.newa()
 if err := container.ensure(a); err != nil {
  fmt.println(err)
  return
 }
 // 打印指针，确保单例和实例的指针地址
 fmt.printf("db: %p\ndb1: %p\nb: %p\nb1: %p\n", a.db, a.db1, &a.b, &a.b1)
}

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

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

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

写在最后

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

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