Dependency Injection in Go: Patterns & Best Practices

Master DI patterns for testable Go code

目录

依赖注入 (DI) 是一种基本的设计模式，它促进了 Go 应用程序中干净、可测试和可维护的代码。

无论您是构建 REST API，实现 多租户数据库模式，还是使用 ORM库，了解依赖注入都将显著提高您的代码质量。

go-dependency-injection

什么是依赖注入？

依赖注入是一种设计模式，其中组件从外部源接收其依赖项，而不是内部创建它们。这种方法解耦了组件，使您的代码更加模块化、可测试和可维护。

在 Go 中，由于语言基于接口的设计哲学，依赖注入尤其强大。Go 的隐式接口满足意味着您可以轻松地交换实现，而无需修改现有代码。

为什么在 Go 中使用依赖注入？

提高可测试性：通过注入依赖项，您可以轻松地将真实实现替换为模拟对象或测试替身。这使您可以编写快速、独立且不需要外部服务（如数据库或 API）的单元测试。

更好的可维护性：依赖项在代码中变得显式。当您查看构造函数时，可以立即看到组件需要什么。这使代码库更容易理解和修改。

松耦合：组件依赖于抽象（接口）而不是具体实现。这意味着您可以更改实现而不会影响依赖代码。

灵活性：您可以为不同的环境（开发、测试、生产）配置不同的实现，而无需更改业务逻辑。

构造函数注入：Go 的方式

在 Go 中实现依赖注入最常见且符合习惯的方式是通过构造函数。这些通常命名为 NewXxx 并接受依赖项作为参数。

基本示例

这是一个演示构造函数注入的简单示例：

// 定义一个仓库的接口
type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

// 服务依赖于仓库接口
type UserService struct {
    repo UserRepository
}

// 构造函数注入依赖项
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

// 方法使用注入的依赖项
func (s *UserService) GetUser(id int) (*User, error) {
    return s.repo.FindByID(id)
}

此模式清楚地表明 UserService 需要 UserRepository。您不能在不提供仓库的情况下创建 UserService，这可以防止因缺少依赖项而导致的运行时错误。

多个依赖项

当组件有多个依赖项时，只需将它们作为构造函数参数添加：

type EmailService interface {
    Send(to, subject, body string) error
}

type Logger interface {
    Info(msg string)
    Error(msg string, err error)
}

type OrderService struct {
    repo        OrderRepository
    emailSvc    EmailService
    logger      Logger
    paymentSvc  PaymentService
}

func NewOrderService(
    repo OrderRepository,
    emailSvc EmailService,
    logger Logger,
    paymentSvc PaymentService,
) *OrderService {
    return &OrderService{
        repo:       repo,
        emailSvc:   emailSvc,
        logger:     logger,
        paymentSvc: paymentSvc,
    }
}

依赖注入的接口设计

在实现依赖注入时，一个关键原则是 依赖倒置原则 (DIP)：高层模块不应依赖于低层模块；两者都应依赖于抽象。

在 Go 中，这意味着定义小而专注的接口，只代表组件需要的内容：

// 好：小而专注的接口
type PaymentProcessor interface {
    ProcessPayment(amount float64) error
}

// 差：大接口，包含不必要的方法
type PaymentService interface {
    ProcessPayment(amount float64) error
    RefundPayment(id string) error
    GetPaymentHistory(userID int) ([]Payment, error)
    UpdatePaymentMethod(userID int, method PaymentMethod) error
    // ...还有许多其他方法
}

较小的接口遵循 接口隔离原则——客户端不应依赖于它们不使用的方法。这使您的代码更加灵活且更容易测试。

实际示例：数据库抽象

在 Go 应用程序中使用数据库时，您通常需要抽象数据库操作。以下是依赖注入如何帮助的示例：

// 数据库接口 - 高层次的抽象
type DB interface {
    Query(ctx context.Context, query string, args ...interface{}) (Rows, error)
    Exec(ctx context.Context, query string, args ...interface{}) (Result, error)
    BeginTx(ctx context.Context) (Tx, error)
}

// 仓库依赖于抽象
type UserRepository struct {
    db DB
}

func NewUserRepository(db DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindByID(ctx context.Context, id int) (*User, error) {
    query := "SELECT id, name, email FROM users WHERE id = $1"
    rows, err := r.db.Query(ctx, query, id)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    // ...解析行
}

这种模式在实现 多租户数据库模式 时尤其有用，其中您可能需要在不同的数据库实现或连接策略之间切换。

组合根模式

组合根是您在应用程序入口点（通常是 main）处组装所有依赖项的地方。这集中了依赖项的配置，并使依赖图显式。

func main() {
    // 初始化基础设施依赖项
    db := initDatabase()
    logger := initLogger()
    
    // 初始化仓库
    userRepo := NewUserRepository(db)
    orderRepo := NewOrderRepository(db)
    
    // 使用依赖项初始化服务
    emailSvc := NewEmailService(logger)
    paymentSvc := NewPaymentService(logger)
    userSvc := NewUserService(userRepo, logger)
    orderSvc := NewOrderService(orderRepo, emailSvc, logger, paymentSvc)
    
    // 初始化HTTP处理器
    userHandler := NewUserHandler(userSvc)
    orderHandler := NewOrderHandler(orderSvc)
    
    // 设置路由
    router := setupRouter(userHandler, orderHandler)
    
    // 启动服务器
    log.Fatal(http.ListenAndServe(":8080", router))
}

这种方法使您的应用程序结构清晰，并明确依赖项的来源。在构建 Go中REST API 时，这种模式特别有价值，因为您需要协调多个依赖项的层次。

依赖注入框架

对于具有复杂依赖图的大型应用程序，手动管理依赖项可能会变得繁琐。Go 有几种 DI 框架可以帮助您：

Google Wire（编译时 DI）

Wire 是一个编译时依赖注入工具，它生成代码。它是类型安全的，并且没有运行时开销。

安装：

go install github.com/google/wire/cmd/wire@latest

示例：

// wire.go
//go:build wireinject
// +build wireinject

package main

import "github.com/google/wire"

func InitializeApp() (*App, error) {
    wire.Build(
        NewDB,
        NewUserRepository,
        NewUserService,
        NewUserHandler,
        NewApp,
    )
    return &App{}, nil
}

Wire 在编译时生成依赖注入代码，确保类型安全并消除运行时反射开销。

Uber Dig（运行时 DI）

Dig 是一个使用反射的运行时依赖注入框架。它更灵活但有一些运行时开销。

示例：

import "go.uber.org/dig"

func main() {
    container := dig.New()
    
    // 注册提供者
    container.Provide(NewDB)
    container.Provide(NewUserRepository)
    container.Provide(NewUserService)
    container.Provide(NewUserHandler)
    
    // 调用需要依赖项的函数
    err := container.Invoke(func(handler *UserHandler) {
        // 使用 handler
    })
    if err != nil {
        log.Fatal(err)
    }
}

何时使用框架

使用框架时：

  • 您的依赖图复杂且有多个相互依赖的组件
  • 您有多个相同接口的实现，需要根据配置选择
  • 您想要自动解析依赖项
  • 您正在构建一个大型应用程序，手动连线变得容易出错

使用手动 DI 时：

  • 您的应用程序规模较小到中等
  • 依赖图简单且易于理解
  • 您希望保持依赖项最小且显式
  • 您更喜欢显式代码而不是生成代码

使用依赖注入进行测试

依赖注入的一个主要好处是提高了可测试性。以下是 DI 如何使测试更容易：

单元测试示例

// 测试用的实现
type mockUserRepository struct {
    users map[int]*User
    err   error
}

func (m *mockUserRepository) FindByID(id int) (*User, error) {
    if m.err != nil {
        return nil, m.err
    }
    return m.users[id], nil
}

func (m *mockUserRepository) Save(user *User) error {
    if m.err != nil {
        return m.err
    }
    m.users[user.ID] = user
    return nil
}

// 使用 mock 进行测试
func TestUserService_GetUser(t *testing.T) {
    mockRepo := &mockUserRepository{
        users: map[int]*User{
            1: {ID: 1, Name: "John", Email: "john@example.com"},
        },
    }
    
    service := NewUserService(mockRepo)
    
    user, err := service.GetUser(1)
    assert.NoError(t, err)
    assert.Equal(t, "John", user.Name)
}

此测试运行速度快，不需要数据库，并且在隔离环境中测试业务逻辑。当使用 Go中的ORM库 时，您可以注入模拟仓库来测试服务逻辑，而无需数据库设置。

常见模式和最佳实践

1. 使用接口隔离

保持接口小而专注，只包含客户端实际需要的内容：

// 好：客户端只需要读取用户
type UserReader interface {
    FindByID(id int) (*User, error)
    FindByEmail(email string) (*User, error)
}

// 用于写入的分离接口
type UserWriter interface {
    Save(user *User) error
    Delete(id int) error
}

2. 从构造函数返回错误

构造函数应验证依赖项并在初始化失败时返回错误：

func NewUserService(repo UserRepository) (*UserService, error) {
    if repo == nil {
        return nil, errors.New("用户仓库不能为nil")
    }
    return &UserService{repo: repo}, nil
}

3. 使用上下文传递请求作用域的依赖项

对于请求特定的依赖项（如数据库事务），通过上下文传递它们：

type ctxKey string

const dbKey ctxKey = "db"

func WithDB(ctx context.Context, db DB) context.Context {
    return context.WithValue(ctx, dbKey, db)
}

func DBFromContext(ctx context.Context) (DB, bool) {
    db, ok := ctx.Value(dbKey).(DB)
    return db, ok
}

4. 避免过度注入

不要注入真正内部实现细节的依赖项。如果组件创建和管理自己的辅助对象，那是可以的：

// 好：内部辅助对象不需要注入
type UserService struct {
    repo UserRepository
    // 内部缓存 - 不需要注入
    cache map[int]*User
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{
        repo:  repo,
        cache: make(map[int]*User),
    }
}

5. 文档化依赖项

使用注释来文档化为什么需要依赖项以及任何约束：

// UserService 处理与用户相关的业务逻辑。
// 它需要一个 UserRepository 用于数据访问和一个 Logger 用于
// 错误跟踪。如果在并发上下文中使用，仓库必须是线程安全的。
func NewUserService(repo UserRepository, logger Logger) *UserService {
    // ...
}

何时不使用依赖注入

依赖注入是一个强大的工具，但并不总是必要的：

跳过 DI 的情况：

  • 简单的值对象或数据结构
  • 内部帮助函数或实用程序
  • 一次性脚本或小工具
  • 当直接实例化更清晰和简单时

不使用 DI 的示例：

// 简单结构 - 不需要 DI
type Point struct {
    X, Y float64
}

func NewPoint(x, y float64) Point {
    return Point{X: x, Y: y}
}

// 简单实用程序 - 不需要 DI
func FormatCurrency(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

与 Go 生态系统的集成

依赖注入可以无缝地与其他 Go 模式和工具配合使用。在构建使用 Go标准库进行网页抓取 或 生成PDF报告 的应用程序时，您可以将这些服务注入到业务逻辑中：

type PDFGenerator interface {
    GenerateReport(data ReportData) ([]byte, error)
}

type ReportService struct {
    pdfGen PDFGenerator
    repo   ReportRepository
}

func NewReportService(pdfGen PDFGenerator, repo ReportRepository) *ReportService {
    return &ReportService{
        pdfGen: pdfGen,
        repo:   repo,
    }
}

这允许您在测试期间交换 PDF 生成实现或使用模拟。

总结

依赖注入是编写可维护、可测试的 Go 代码的基石。通过遵循本文中概述的模式——构造函数注入、基于接口的设计和组合根模式——您将创建更容易理解、测试和修改的应用程序。

对于小型到中型应用程序，从手动构造函数注入开始，随着依赖图的增长，考虑使用 Wire 或 Dig 等框架。记住目标是清晰度和可测试性，而不是为了复杂性而复杂。

如需更多 Go 开发资源，请查看我们的 Go速查表，以快速查阅 Go 语法和常见模式。

有用的链接

外部资源