浅谈golang的依赖注入
如果是做web开发，对依赖注入肯定不陌生，java程序员早就习惯了spring提供的依赖注入，做业务开发时非常方便，只关注业务逻辑即可，对象之间的依赖关系都交给框架。
golang是强类型语言，编译后是机器码，所以一般使用 反射 或 代码生成 解决依赖注入的问题
基于反射的DI
基于反射解决DI问题的框架, 使用比较多的是Uber的 dig 库
github地址：https://github.com/uber-go/dig
官方的例子：
type Config struct {
Prefix string
}
//初始化Config函数
func NewConfig()(*Config, error) {
// In a real program, the configuration will probably be read from a
// file.
var cfg Config
err := json.Unmarshal([]byte(`{"prefix": "[foo] "}`), &cfg)
return &cfg, err
}
//初始化logger函数
func NewLogger(cfg *Config) *log.Logger {
return log.New(os.Stdout, cfg.Prefix, 0)
}
func Handle() (l *log.Logger) {
l.Print("You've been invoked")
}
func main() {
//初始化dig对象
c := dig.New()
//Provide方法用来设置依赖的对象
er := c.Provide(NewConfig)
if err != nil {
panic(err)
}
//设置依赖的对象
err = c.Provide(NewLogger)
if err != nil {
panic(err)
}
//执行Handle()方法
//Handle依赖 Config 和 Logger，使用Invoke执行方法时会自动注入依赖（依赖的对象要传入Provide方法中）
err = c.Invoke(Handle)
if err != nil {
panic(err)
}
// Output:
// [foo] You've been invoked}dig提供了一个容器(container)，所有的依赖项通过Provide方法添加，执行某个方法时使用Invoke方法，该方法会自动注入所需要的依赖。
dig使用反射机制解决DI问题，所以代码执行性能上会有损耗
并且因为使用反射所以可能出现编译时没有错误，执行时报空指针
详情使用方法可以参考官方文档，dig可以继承到gin框架中，有兴趣的可以看看资料。
笔者不太喜欢这种使用方式，为了依赖注入破坏了代码原有的调用方式。
基于代码生成的DI
wire库是google出的解决golang DI问题的工具，它可以 自动生成依赖注入的代码，节省了手动去处理依赖关系
github地址：https://github.com/google/wire
wire对原有代码的侵入度很低，开发过程中，在依赖注入代码处调用Build方法（例子中是初始化controller对象）就可以了
// +build wireinject
package main
import (
"encoding/json"
"fmt"
"github.com/google/wire"
"net/http"
)
type DataSource struct {
Operation string
}
func NewDataSource() DataSource {
return DataSource{Operation: "operation_name"}
}
//==================
type Dao struct {
DataSource DataSource
}
func NewDao(ds DataSource) *Dao {
return &Dao{
DataSource: ds,
}
}
func (d *Dao) GetItemList() ([]string, error) {
//TODO 拿到DB对象做查询操作
fmt.Printf("db object: %s", d.DataSource.Operation)
return []string{d.DataSource.Operation, "item1", "item2"}, nil
}
//====================
type Service struct {
Dao *Dao
}
func NewService(dao *Dao) *Service {
return &Service{Dao: dao}
}
func (s *Service) GetItemList() ([]string, error) {
return s.Dao.GetItemList()
}
//=====================
type Controller struct {
Service *Service
}
func NewController(service *Service) *Controller {
return &Controller{Service: service}
}
func (c *Controller) GetItemList() ([]string, error) {
return c.Service.GetItemList()
}
var MegaSet = wire.NewSet(NewDataSource, NewDao, NewService, NewController)
func initializeController() *Controller {
wire.Build(MegaSet)
return &Controller{}
}
func getItemList(w http.ResponseWriter, r *http.Request) {
controller := initializeController()
itemList, _ := controller.GetItemList()
output, _ := json.Marshal(itemList)
fmt.Fprintf(w, string(output))
}
func main() {
http.HandleFunc("/items", getItemList)
err := http.ListenAndServe(":8080", nil)
if err != nil {
panic(err)
}}gist地址：https://gist.github.com/huarong8/fa9d1f2322fdbd8536402c81437b2567
然后再项目根目录执行wire命令，会生成构建好依赖关系的代码(以_gen结尾的文件)
// Code generated by Wire. DO NOT EDIT.
//go:generate go run github.com/google/wire/cmd/wire
//+build !wireinject
package main
import (
"encoding/json"
"fmt"
"github.com/google/wire"
"net/http"
)
// Injectors from main.go:
// 此处是生成的代码
func initializeController() *Controller {
dataSource := NewDataSource()
dao := NewDao(dataSource)
service := NewService(dao)
controller := NewController(service)
return controller
}
// main.go:
type DataSource struct {
Operation string
}
func NewDataSource() DataSource {
return DataSource{Operation: "operation_name"}
}
type Dao struct {
DataSource DataSource
}
func NewDao(ds DataSource) *Dao {
return &Dao{
DataSource: ds,
}
}
func (d *Dao) GetItemList() ([]string, error) {
fmt.Printf("db object: %s", d.DataSource.Operation)
return []string{d.DataSource.Operation, "item1", "item2"}, nil
}
type Service struct {
Dao *Dao
}
func NewService(dao *Dao) *Service {
return &Service{Dao: dao}
}
func (s *Service) GetItemList() ([]string, error) {
return s.Dao.GetItemList()
}
type Controller struct {
Service *Service
}
func NewController(service *Service) *Controller {
return &Controller{Service: service}
}
func (c *Controller) GetItemList() ([]string, error) {
return c.Service.GetItemList()
}
var MegaSet = wire.NewSet(NewDataSource, NewDao, NewService, NewController)
func getItemList(w http.ResponseWriter, r *http.Request) {
controller := initializeController()
itemList, _ := controller.GetItemList()
output, _ := json.Marshal(itemList)
fmt.Fprintf(w, string(output))
}
func main() {
http.HandleFunc("/items", getItemList)
err := http.ListenAndServe(":8080", nil)
if err != nil {
panic(err)
}}关键代码
//执行wire命令前的代码
func initializeController() *Controller {
wire.Build(MegaSet)
return &Controller{}
}
//执行后生成的代码
// Injectors from main.go:
func initializeController() *Controller {
dataSource := NewDataSource()
dao := NewDao(dataSource)
service := NewService(dao)
controller := NewController(service)
return controller}通过生成代码解决依赖注入的问题，既能提升开发效率，又不影响代码性能，wire更高级的用法可以去github document查看
tips: 如果报错误 other declaration of xxxx ，请在源文件头加上 //+build wireinject
go-zero框架也是用wire解决DI问题
