go-dependency-injection

Go Dependency Injection

DI in Go is a pattern, not a framework: pass dependencies to constructors, wire everything explicitly in main. Reach for a framework only when manual wiring measurably hurts.

1. Constructor Injection — the Default

// ✅ Good — dependencies are explicit parameters
type OrderService struct {
    repo     OrderRepository
    payments PaymentGateway
    logger   *slog.Logger
}

func NewOrderService(repo OrderRepository, payments PaymentGateway, logger *slog.Logger) *OrderService {
    return &OrderService{repo: repo, payments: payments, logger: logger}
}

// ❌ Bad — hidden dependencies reached through globals
func (s *OrderService) Place(ctx context.Context, o Order) error {
    db := database.Get()        // global singleton
    log.Printf("placing order") // global logger
    // untestable without touching process-wide state
}

Rules:

• Accept interfaces for dependencies the service calls; return the concrete type from the constructor.
• Every dependency visible in the signature — if the list feels long, the type does too much (split it), don't hide deps to shorten it.
• Validate required deps in the constructor and return an error (or accept a nil-safe default, e.g. logger = slog.Default()).

2. The Composition Root

All wiring lives in one place — main (or a run function it calls). Construction order is the dependency order, checked by the compiler:

func run(ctx context.Context, cfg Config) error {
    db, err := store.Open(ctx, cfg.DatabaseURL)
    if err != nil {
        return fmt.Errorf("open db: %w", err)
    }
    defer db.Close()

    orderRepo := store.NewOrderRepo(db)
    payments := stripe.NewGateway(cfg.StripeKey)
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

    orders := service.NewOrderService(orderRepo, payments, logger)
    server := handler.NewServer(cfg.Addr, orders)

    return server.ListenAndServe(ctx)
}

• No package builds its own dependencies; it receives them.
• No init() wiring, no package-level var DB *sql.DB.
• Two binaries needing different wiring = two mains, same components.