Go工程化 - Uber Fx依赖注入实战

DI 的价值

依赖注入（DI）将“对象的创建”与“对象的使用”解耦，带来：可测试性提升（可注入 Mock）、启动流程清晰（构造器组织）、生命周期统一（资源启停）、模块边界明确。Uber Fx 是 Go 生态中工程化程度较高的 DI 框架，内置生命周期与日志/metrics 接口。

基本概念

Provide：向容器注册构造器（constructor）
Invoke：在容器完成图构建后调用入口函数
Lifecycle：统一资源启动/停止（连接池、后台协程等）
Module：组合多个 Provide/Invoke 形成可复用单元
Annotate/As/Name：标注、接口绑定、命名实例，解决多实现与歧义

快速上手

type Config struct{ DSN string }
type DB struct{ DSN string }

func NewConfig() *Config { return &Config{DSN: "mysql://user:pwd@tcp(localhost:3306)/app"} }
func NewDB(c *Config) (*DB, error) { return &DB{DSN: c.DSN}, nil }

func main() {
  app := fx.New(
    fx.Provide(NewConfig, NewDB),
    fx.Invoke(func(lc fx.Lifecycle, db *DB) {
      lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error { fmt.Println("db ready"); return nil },
        OnStop:  func(ctx context.Context) error { fmt.Println("db closed"); return nil },
      })
    }),
  )
  app.Run()
}

模块化与接口绑定

type Repo interface { Save(ctx context.Context, v any) error }
type repo struct{ db *DB }

func NewRepo(db *DB) Repo { return &repo{db: db} }

var RepoModule = fx.Module("repo",
  fx.Provide(
    NewRepo,
    fx.Annotate(NewRepo, fx.As(new(Repo))), // 接口绑定
  ),
)

服务与 HTTP 层模块：

type Service struct{ r Repo }
func NewService(r Repo) *Service { return &Service{r} }

type HTTP struct{ s *Service }

func NewHTTP(lc fx.Lifecycle, s *Service) *HTTP {
  h := &HTTP{s}
  lc.Append(fx.Hook{
    OnStart: func(ctx context.Context) error { go h.serve(); return nil },
    OnStop:  func(ctx context.Context) error { return h.shutdown(ctx) },
  })
  return h
}

多实现与命名实例

type Cache interface { Get(k string) (string, bool) }
type lruCache struct{}
type redisCache struct{}

func NewLRU() Cache   { return &lruCache{} }
func NewRedis() Cache { return &redisCache{} }

var CacheModule = fx.Options(
  fx.Provide(
    fx.Annotate(NewLRU, fx.As(new(Cache)), fx.ResultTags(`name:"local"`)),
    fx.Annotate(NewRedis, fx.As(new(Cache)), fx.ResultTags(`name:"remote"`)),
  ),
  fx.Invoke(func(@name("local") c1 Cache, @name("remote") c2 Cache) {
    _ = c1; _ = c2
  }),
)

配置、日志与可观测性注入

type AppCfg struct{ Env string }
func LoadCfg() (*AppCfg, error) { return &AppCfg{Env: "prod"}, nil }

func NewLogger(cfg *AppCfg) *zap.Logger {
  if cfg.Env == "prod" {
    l, _ := zap.NewProduction()
    return l
  }
  l, _ := zap.NewDevelopment()
  return l
}

var ObsModule = fx.Module("obs",
  fx.Provide(LoadCfg, NewLogger),
  fx.Invoke(func(l *zap.Logger) { l.Info("logger ready") }),
)

测试与可替换性

利用 Provide 覆盖注入 Mock：

func TestSvc(t *testing.T) {
  mockRepo := new(MockRepo)
  app := fx.NewForTest(t,
    fx.Provide(func() Repo { return mockRepo }),
    fx.Provide(NewService),
    fx.Invoke(func(s *Service) {
      // 断言业务逻辑
    }),
  )
  app.RequireStart().RequireStop()
}