本文介绍了golang不到30行代码实现依赖注入的方法，分享给大家，具体如下：
项目地址
本项目依赖
使用标准库实现，无额外依赖
依赖注入的优势
用java的人对于spring框架一定不会陌生，spring核心就是一个IoC(控制反转/依赖注入)容器，带来一个很大的优势是解耦。一般只依赖容器，而不依赖具体的类，当你的类有修改时，最多需要改动一下容器相关代码，业务代码并不受影响。
golang的依赖注入原理
总的来说和java的差不多，步骤如下：(golang不支持动态创建对象，所以需要先手动创建对象然后注入，java可以直接动态创建对象)
- 通过反射读取对象的依赖(golang是通过tag实现)
- 在容器中查找有无该对象实例
- 如果有该对象实例或者创建对象的工厂方法，则注入对象或使用工厂创建对象并注入
- 如果无该对象实例，则报错
代码实现
一个典型的容器实现如下，依赖类型参考了spring的singleton/prototype，分别对象单例对象和实例对象:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
package diimport ( "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对象
测试
- 单例对象在整个容器中只有一个实例，所以不管在何处注入，获取到的指针一定是一样的。
- 实例对象是通过同一个工厂方法创建的，所以每个实例的指针不可以相同。
下面是测试入口代码，完整代码在github仓库，有兴趣的可以翻阅：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package mainimport ( "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的指针不同，说明不是一个实例。
写在最后
通过依赖注入可以很好的管理多个对象之间的实例化以及依赖关系，配合配置文件在应用初始化阶段将需要注入的实例注册到容器中，在应用的任何地方只需要在实例化时注入容器即可。没有额外依赖。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://segmentfault.com/a/1190000015752299
