Go 中的依赖注入：模式与最佳实践

Source: Dev.to

Introduction

依赖注入（DI）是一种基础的设计模式，能够在 Go 应用中促进代码的整洁、可测试和可维护。通过从外部获取依赖而不是在内部创建它们，组件变得解耦、模块化，且更易于使用。

Benefits of Dependency Injection

• Improved Testability – 用 mock 或测试替身替换真实实现，从而实现快速、独立的单元测试，无需外部服务。
• Better Maintainability – 依赖在构造函数中显式声明，清晰地表明组件需要什么。
• Loose Coupling – 组件依赖抽象（接口）而非具体类型，使实现可以在不影响使用者的情况下更换。
• Flexibility – 为开发、测试和生产环境配置不同实现，而无需修改业务逻辑。

Constructor Injection (Idiomatic Go)

在 Go 中实现 DI 最常见的方式是通过构造函数，通常命名为 NewXxx，并将依赖作为参数传入。

// Define an interface for the repository
type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

// Service depends on the repository interface
type UserService struct {
    repo UserRepository
}

// Constructor injects the dependency
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

// Methods use the injected dependency
func (s *UserService) GetUser(id int) (*User, error) {
    return s.repo.FindByID(id)
}

Multiple Dependencies

当一个组件需要多个协作者时，所有依赖都列在构造函数的参数中：

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,
    }
}

Dependency Inversion Principle (DIP) & Interface Segregation

高层模块应依赖抽象，而不是具体实现。在 Go 中，这意味着要定义小而专注的接口。

// Good: Small, focused interface
type PaymentProcessor interface {
    ProcessPayment(amount float64) error
}

// Bad: Large interface with unnecessary methods
type PaymentService interface {
    ProcessPayment(amount float64) error
    RefundPayment(id string) error
    GetPaymentHistory(userID int) ([]Payment, error)
    UpdatePaymentMethod(userID int, method PaymentMethod) error
    // ... many more methods
}

窄接口遵循接口分离原则，避免客户端依赖它们不使用的方法。

Database Abstraction Example

// Database interface – high‑level abstraction
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)
}

// Repository depends on the abstraction
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()
    // ... parse rows
    return nil, nil
}

该模式在多租户数据库或需要在不同驱动之间切换时尤为有用。

Composition Root

Composition Root 是唯一的地方（通常是 main），在这里组装完整的对象图：

func main() {
    // Initialize infrastructure dependencies
    db := initDatabase()
    logger := initLogger()

    // Initialize repositories
    userRepo := NewUserRepository(db)
    orderRepo := NewOrderRepository(db)

    // Initialize services with dependencies
    emailSvc := NewEmailService(logger)
    paymentSvc := NewPaymentService(logger)
    userSvc := NewUserService(userRepo, logger)
    orderSvc := NewOrderService(orderRepo, emailSvc, logger, paymentSvc)

    // Initialize HTTP handlers
    userHandler := NewUserHandler(userSvc)
    orderHandler := NewOrderHandler(orderSvc)

    // Wire up routes
    router := setupRouter(userHandler, orderHandler)

    // Start server
    log.Fatal(http.ListenAndServe(":8080", router))
}

这使得依赖图明确化，简化了对应用结构的推理，对 REST API 和其他分层系统尤为有价值。

DI Frameworks for Larger Projects

Wire (compile‑time)

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
}

Dig (runtime)

Dig 使用反射在运行时解析依赖，提供更大的灵活性，但会有一定的开销。

import "go.uber.org/dig"

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

    // Register providers
    container.Provide(NewDB)
    container.Provide(NewUserRepository)
    container.Provide(NewUserService)
    container.Provide(NewUserHandler)

    // Invoke a function that needs dependencies
    err := container.Invoke(func(handler *UserHandler) {
        // Use handler
    })
    if err != nil {
        log.Fatal(err)
    }
}

When to Use a Framework vs. Manual DI

• Use a framework when:

  • The dependency graph is complex with many interdependent components.
  • Multiple implementations of the same interface must be selected based on configuration.
  • Automatic resolution would reduce boilerplate and error‑prone wiring.
  • You are building a large application where manual wiring becomes cumbersome.

• Stick with manual DI when:

  • The application is small to medium‑size and the graph remains simple.
  • You prefer explicit wiring without additional dependencies.