Go Dependency Injection
with uber/fx

fx.Provide(
    config.New,
    database.New,
    NewArticleUsecase,
)

New(cfg *config.Config) (*sql.DB, error)
     ↑ needs            ↑ provides

go get go.uber.org/fx

fx has a lot of methods and they blur together. We open the map on the next slide first, then fill it in chapter by chapter with real examples.

app := fxtest.New(t,
    // Provide: registers constructors only. Nothing runs yet.
    fx.Provide(
        NewLogger,        // returns Logger
        NewMysqlUserRepo, // returns UserRepository (needs Logger)
        NewUserService,   // returns *UserService (needs UserRepository)
    ),
    // Invoke: this is where the graph finally gets assembled
    fx.Invoke(func(s *UserService) { svc = s }),
)

// An app with Provides but no Invoke
→ not a single constructor runs. The app starts quietly and exits quietly.

// cmd/main.go
app := fx.New(
    fx.Provide(
        config.New,              // *config.Config
        database.New,            // *sql.DB          (needs *config.Config)
        NewEcho,                 // *echo.Echo

        // an anonymous function is a constructor too — only the types matter
        func(cfg *config.Config) time.Duration {
            return time.Duration(cfg.Context.Timeout) * time.Second
        },

        article.NewArticleHandler,         // needs Echo, UseCase
        article.NewArticleUsecase,         // needs Repo, AuthorRepo, Duration
        article.NewMysqlArticleRepository, // needs DB
        author.NewMysqlAuthorRepository,   // needs DB
    ),
    fx.Invoke(registerHooks),   // start the server
)

Arrows are the direction of dependency. fx builds this graph with no declaration at all — parameter and return types are the whole input. If a cycle appears, it tells you at startup exactly where things are tangled.

func registerHooks(lifecycle fx.Lifecycle, e *echo.Echo, cfg *config.Config) {
    lifecycle.Append(fx.Hook{
        OnStart: func(context.Context) error {
            fmt.Println("Starting server")
            go e.Start(cfg.Server.Address)
            return nil
        },
        OnStop: func(context.Context) error {
            fmt.Println("Stopping server")
            return nil
        },
    })
}

// Logging decorator: wraps the existing UserRepository
type loggingUserRepo struct {
    inner  UserRepository
    logger Logger
}

func (r *loggingUserRepo) FindByID(id int) string {
    r.calls = append(r.calls, fmt.Sprintf("FindByID(%d)", id))
    return r.inner.FindByID(id)   // call the original
}

app := fxtest.New(t,
    fx.Provide(NewLogger, NewMysqlUserRepo, NewUserService),
    fx.Decorate(func(repo UserRepository, logger Logger) UserRepository {
        return &loggingUserRepo{inner: repo, logger: logger}
    }),
)

app := fxtest.New(t,
    fx.Provide(NewLogger, NewMysqlUserRepo, NewUserService),
    fx.Invoke(func(svc *UserService) { /* ... */ }),
)
defer app.RequireStop()
app.RequireStart()

app := fxtest.New(t,
    fx.Provide(NewLogger, NewMysqlUserRepo, NewUserService),

    // replace the real UserRepository with a mock
    fx.Replace(fx.Annotate(&mockUserRepo{}, fx.As(new(UserRepository)))),

    fx.Invoke(func(svc *UserService) {
        result := svc.repo.FindByID(1)
        // result == "mock-user-1"
    }),
)

• fx builds the dependency graph from nothing but constructors' parameter and return types — assembly order disappears from the code
• Provide is lazy registration, Invoke is eager execution. Without Invoke, nothing happens
• Lifecycle has two stages — New registers the hooks, Start runs their bodies
• As the app grows: group with Module, wrap with Decorate, distinguish with name/group, hide with Private
• Testing is fxtest + Replace (don't forget fx.As) + Populate
• Don't manage everything with fx. It shines brightest on components that have a lifecycle