4. 手动依赖注入实战：构造函数注入、接口注入、使用 wire 进行依赖注入、wire 的安装与基础用法

依赖注入（Dependency Injection, DI）是构建可测试、可扩展 Go 服务的核心实践。本章从最基础的手动注入开始，逐步过渡到接口注入，最后引入 Google 官方工具 wire 实现自动化依赖组装。你将掌握三种注入方式的适用场景与实现细节。

4.1 构造函数注入：最直观的依赖传递

构造函数注入通过将依赖作为参数传入构造函数，在对象创建时完成依赖绑定。这是 Go 中最常见、最符合显式依赖原则的方式。

核心原则：依赖在构造时确定，运行时不可变。适合生命周期与宿主对象一致的依赖（如数据库连接、日志器、配置对象）。 
// 定义依赖接口
type Logger interface {
    Log(message string)
}

type ConsoleLogger struct{}

func (c *ConsoleLogger) Log(message string) {
    fmt.Println("[LOG]", message)
}

// 依赖方：通过构造函数注入
type UserService struct {
    logger Logger
    db     *sql.DB
}

// NewUserService 构造函数注入所有依赖
func NewUserService(logger Logger, db *sql.DB) *UserService {
    return &UserService{
        logger: logger,
        db:     db,
    }
}

// 使用
func main() {
    logger := &ConsoleLogger{}
    db, _ := sql.Open("postgres", "dsn")
    svc := NewUserService(logger, db)
    svc.logger.Log("UserService created")
}
特性 说明
显式性 依赖列表一目了然，代码即文档
编译安全 缺少依赖时编译失败，不会运行时才暴露
测试友好 传入 mock 对象即可隔离测试
局限性 依赖层次深时，手动组装代码冗长

4.2 接口注入：解耦依赖的具体实现

接口注入不直接依赖具体类型，而是通过接口参数传递依赖。这种方式让调用方可以灵活替换实现，是 Go 依赖注入的核心思想。

// 定义存储接口
type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

// 具体实现
type PostgresUserRepo struct {
    db *sql.DB
}

func (r *PostgresUserRepo) FindByID(id int) (*User, error) {
    // 实现...
    return nil, nil
}

// 服务层通过接口注入
type UserService struct {
    repo UserRepository  // 依赖接口而非具体类型
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

// 测试时注入 mock
type MockUserRepo struct{}

func (m *MockUserRepo) FindByID(id int) (*User, error) {
    return &User{ID: id, Name: "mock"}, nil
}

func TestUserService(t *testing.T) {
    mockRepo := &MockUserRepo{}
    svc := NewUserService(mockRepo)
    // 测试逻辑...
}
最佳实践：接口定义在消费方（依赖方）而非实现方。这样实现方不需要导入消费方的包，避免循环依赖。

4.3 手动依赖注入 vs 接口注入对比

维度 构造函数注入 接口注入
依赖类型 具体类型或接口 仅接口
耦合度 中等（依赖具体类型时高） 低（完全面向接口）
测试替换 需实现相同接口 直接实现接口即可
代码量 少 需额外定义接口
适用场景 小型项目、依赖稳定 大型项目、需要频繁 mock
手动依赖注入流程：构造函数注入 + 接口注入 构造函数注入 NewUserService(logger, db) 内部赋值：s.logger = logger 依赖在构造时固定 运行时不可替换 接口注入 NewUserService(repo UserRepository) 依赖接口，不依赖实现 可注入 PostgresRepo / MockRepo 测试时灵活替换

4.4 手动依赖注入的痛点

随着项目规模增长，手动注入的缺点逐渐暴露：

  • 组装代码膨胀：每新增一个服务，就要在 main 函数或初始化函数中手动创建所有依赖链。
  • 依赖顺序敏感：必须按正确的顺序创建对象，否则编译或运行时报错。
  • 重构成本高：修改构造函数签名时，所有调用处都需要同步修改。
  • 循环依赖难以发现：手动组装时循环依赖只在运行时暴露。
典型反例：一个包含 20+ 服务的 main 函数，手动创建依赖链超过 100 行，每次新增字段都要逐层修改。此时应引入自动依赖注入工具。

4.5 wire 的安装与基础用法

wire 是 Google 开源的 Go 依赖注入工具，通过代码生成实现编译期依赖注入，避免运行时反射开销。

安装 wire

# 方式一：go install（推荐）
go install github.com/google/wire/cmd/wire@latest

# 验证安装
wire -h

# 方式二：在项目中添加工具依赖
go get github.com/google/wire/cmd/wire

基础用法三步走

  1. 定义 Provider：提供依赖的构造函数。
  2. 编写 Injector：声明需要组装的对象和依赖关系。
  3. 运行 wire：自动生成组装代码。
// 1. provider.go - 定义提供者
package main

import "fmt"

type Message string

func NewMessage() Message {
    return Message("Hello, Wire!")
}

type Greeter struct {
    Message Message
}

func NewGreeter(m Message) Greeter {
    return Greeter{Message: m}
}

type Event struct {
    Greeter Greeter
}

func NewEvent(g Greeter) Event {
    return Event{Greeter: g}
}

// 2. wire.go - 编写 injector 声明
// +build wireinject

package main

import "github.com/google/wire"

func InitializeEvent() Event {
    wire.Build(NewEvent, NewGreeter, NewMessage)
    return Event{} // 占位，wire 会覆盖
}

// 3. 在项目根目录运行 wire 命令
// $ wire
// 自动生成 wire_gen.go 文件
// wire_gen.go - wire 自动生成的代码
// Code generated by Wire. DO NOT EDIT.

package main

func InitializeEvent() Event {
    message := NewMessage()
    greeter := NewGreeter(message)
    event := NewEvent(greeter)
    return event
}
关键理解：wire 不是运行时框架，而是代码生成器。它分析 wire.Build 中的 provider 签名，自动推导依赖顺序并生成正确的初始化代码。生成的代码是纯 Go，无反射，无运行时依赖。

4.6 wire 的核心概念

概念 说明 示例
Provider 返回值的函数，wire 用它创建依赖 func NewDB() *sql.DB
Injector 调用 wire.Build 的函数，声明依赖图 func InitializeApp() *App
Provider Set 将多个 provider 组合成集合 var Set = wire.NewSet(NewA, NewB)
Binding 将接口绑定到具体实现 wire.Bind(new(Repo), new(*PostgresRepo))
Cleanup provider 可返回清理函数，wire 自动管理 func NewDB() (*sql.DB, func())

4.7 接口绑定与 Provider Set 实战

// repo.go
type UserRepo interface {
    GetUser(id int) string
}

type PostgresRepo struct{}

func (p *PostgresRepo) GetUser(id int) string {
    return "user from postgres"
}

func NewPostgresRepo() *PostgresRepo {
    return &PostgresRepo{}
}

// service.go
type UserService struct {
    repo UserRepo
}

func NewUserService(repo UserRepo) *UserService {
    return &UserService{repo: repo}
}

// wire.go
// +build wireinject

package main

import "github.com/google/wire"

// 定义 provider set
var RepoSet = wire.NewSet(
    NewPostgresRepo,
    wire.Bind(new(UserRepo), new(*PostgresRepo)),
)

var ServiceSet = wire.NewSet(
    NewUserService,
    RepoSet,
)

func InitializeUserService() *UserService {
    wire.Build(ServiceSet)
    return nil
}

// 运行 wire 后，生成的代码自动完成接口绑定
// func InitializeUserService() *UserService {
//     postgresRepo := NewPostgresRepo()
//     userService := NewUserService(postgresRepo)
//     return userService
// }
wire 依赖注入流程：从声明到生成 阶段1：编写声明 wire.Build(Provider...) wire.Bind(接口, 实现) wire.NewSet(组合) 阶段2：执行 wire $ wire 分析依赖图 检测循环依赖 阶段3：生成代码 wire_gen.go 编译期安全 零运行时开销

4.8 常见问题与避坑指南

常见错误1：忘记在 wire.go 文件头部添加 // +build wireinject 构建标签。这会导致 wire 无法识别 injector 文件，或者生成的代码与手动代码冲突。
常见错误2：provider 返回接口类型而非具体类型。wire 要求 provider 返回具体类型，接口绑定通过 wire.Bind 单独声明。
调试技巧：运行 wire check 只检查依赖图而不生成代码，快速定位循环依赖或缺失 provider 的问题。
$ wire check ./...
问题 原因 解决方案
wire: no provider found 缺少某个依赖的 provider 检查 wire.Build 是否包含所有 provider
wire: cycle detected 存在循环依赖 重构代码，引入接口或拆分模块
wire: multiple providers 同一类型有多个 provider 使用 wire.Value 或 wire.NewSet 区分
生成代码未更新 忘记重新运行 wire 每次修改 provider 后执行 wire

4.9 三种注入方式的选择策略

项目规模 推荐方式 理由
小型（<5 个服务） 构造函数注入 简单直接，无需额外工具
中型（5-20 个服务） 接口注入 + 手动组装 测试友好，依赖关系可控
大型（>20 个服务） wire 自动注入 减少重复代码，编译期检查依赖

无论选择哪种方式，核心目标始终一致：让依赖关系显式化、可测试、可维护。手动注入是基础，接口注入是解耦的关键，wire 是规模化后的效率工具。三者不是互斥的，可以在同一项目中混合使用。

← 上一章 📖 返回目录 下一章 →