Golang 依赖注入工具 dig 使用指南

dig 是 Uber 开源的基于反射的 Go 语言依赖注入容器，它可以帮助管理应用程序中的对象创建和依赖关系。

基本概念

dig 的核心概念包括：

• Container：依赖注入容器，存储所有已注册的构造函数和值
• Provide：向容器注册构造函数或值
• Invoke：从容器中获取依赖并执行函数

安装

go get go.uber.org/dig

基本使用示例

package main

import (
	"fmt"
	"go.uber.org/dig"
)

type Config struct {
	Host string
	Port int
}

type Server struct {
	config *Config
}

func NewConfig() *Config {
	return &Config{
		Host: "localhost",
		Port: 8080,
	}
}

func NewServer(cfg *Config) *Server {
	return &Server{config: cfg}
}

func (s *Server) Start() {
	fmt.Printf("Server starting on %s:%d\n", s.config.Host, s.config.Port)
}

func main() {
	// 创建容器
	c := dig.New()

	// 注册构造函数
	err := c.Provide(NewConfig)
	if err != nil {
		panic(err)
	}

	err = c.Provide(NewServer)
	if err != nil {
		panic(err)
	}

	// 使用依赖
	err = c.Invoke(func(s *Server) {
		s.Start()
	})
	if err != nil {
		panic(err)
	}
}

高级特性

1. 命名值和组值

func main() {
	c := dig.New()

	// 注册命名值
	err := c.Provide(func() (*Config, error) {
		return &Config{Host: "localhost", Port: 8080}, nil
	}, dig.Name("primary"))
	
	// 注册组值
	err = c.Provide(func() (*Config, error) {
		return &Config{Host: "backup", Port: 8081}, nil
	}, dig.Name("backup"))
	
	// 使用命名值
	err = c.Invoke(func(cfg *Config, dig.In) {
		fmt.Printf("Using config: %+v\n", cfg)
	})
}

2. 接口绑定

type Logger interface {
	Log(string)
}

type FileLogger struct{}

func (l *FileLogger) Log(msg string) {
	fmt.Println("File logger:", msg)
}

func NewLogger() Logger {
	return &FileLogger{}
}

func main() {
	c := dig.New()

	// 绑定接口实现
	err := c.Provide(NewLogger, dig.As(new(Logger)))
	if err != nil {
		panic(err)
	}

	err = c.Invoke(func(l Logger) {
		l.Log("Hello, dig!")
	})
	if err != nil {
		panic(err)
	}
}

3. 可选依赖

func main() {
	c := dig.New()

	// 注册可选依赖
	type OptionalParams struct {
		dig.In
		Logger Logger `optional:"true"`
	}

	err := c.Invoke(func(params OptionalParams) {
		if params.Logger != nil {
			params.Logger.Log("Optional logger present")
		} else {
			fmt.Println("No logger provided")
		}
	})
	if err != nil {
		panic(err)
	}
}

4. 生命周期管理

func main() {
	c := dig.New()

	err := c.Provide(func() (*Config, func(), error) {
		cfg := &Config{Host: "localhost", Port: 8080}
		cleanup := func() {
			fmt.Println("Cleaning up config")
		}
		return cfg, cleanup, nil
	})
	if err != nil {
		panic(err)
	}

	err = c.Invoke(func(cfg *Config) {
		fmt.Printf("Using config: %+v\n", cfg)
	})
	if err != nil {
		panic(err)
	}
}

最佳实践

1. 保持构造函数简单：每个构造函数只负责创建一种类型
2. 避免循环依赖：dig 无法处理循环依赖
3. 使用接口：提高代码的可测试性和灵活性
4. 合理使用命名和组：当同一类型有多个实例时
5. 处理错误：dig 的 Provide 和 Invoke 都可能返回错误

与 Wire 的比较

dig 是基于反射的依赖注入工具，而 Wire 是基于代码生成的。dig 的优势在于运行时灵活性，Wire 的优势在于编译时安全和更好的性能。

dig 适合：

• 需要运行时动态配置的应用
• 小型到中型项目
• 需要快速原型开发

Wire 适合：

• 大型项目
• 需要编译时依赖检查
• 性能敏感的应用

总结

dig 是一个功能强大且灵活的依赖注入工具，特别适合需要运行时依赖管理的场景。通过合理使用 dig 的各种特性，可以大大简化 Go 应用程序的依赖管理，提高代码的可维护性和可测试性。