Dependency injection tanpa framework

Di Go, dependency injection biasanya berarti "oper lewat parameter konstruktor". Tidak ada anotasi, tidak ada container, tidak ada resolusi saat runtime — dan justru itu yang membuat kesalahan perakitan ketahuan saat kompilasi.

Bentuk yang dipakai

// cmd/server/main.go — SATU-SATUNYA tempat yang tahu semua bagian
func jalankan(ctx context.Context) error {
	cfg, err := config.Muat()
	if err != nil {
		return err
	}

	log := slog.New(slog.NewJSONHandler(os.Stdout,
		&slog.HandlerOptions{Level: cfg.LevelLog}))

	pool, err := platform.BukaPool(ctx, cfg.DSN)
	if err != nil {
		return err
	}
	defer pool.Close()

	rdb := platform.BukaRedis(cfg.Redis)
	defer rdb.Close()

	// Infrastruktur → domain → transport. Arahnya selalu ke atas.
	produkRepo := postgres.NewProdukRepo(pool)
	produkCache := cache.NewRedis(rdb, "produk", time.Minute)
	produkSvc := produk.NewLayanan(produkRepo, produkCache, log)

	pesananRepo := postgres.NewPesananRepo(pool)
	pesananSvc := pesanan.NewLayanan(pesananRepo, produkSvc, log)

	h := httpapi.New(produkSvc, pesananSvc, log)

	srv := &http.Server{Addr: cfg.Addr, Handler: h.Rute() /* timeout... */}
	return sajikan(ctx, srv, log)
}

func main() {
	ctx, hentikan := signal.NotifyContext(context.Background(),
		os.Interrupt, syscall.SIGTERM)
	defer hentikan()

	if err := jalankan(ctx); err != nil {
		slog.Error("aplikasi berhenti", "err", err)
		os.Exit(1)
	}
}

Kenapa bukan global

// ❌ Terlihat praktis, dan menghancurkan tiga hal sekaligus
var DB *sql.DB

func init() {
	DB, _ = sql.Open("pgx", os.Getenv("DATABASE_URL"))
}

func AmbilProduk(id int64) (Produk, error) {
	return DB.QueryRow(...)   // dependensi tak terlihat dari tanda tangan
}

Bergantung pada perilaku, bukan pada implementasi

// internal/pesanan/layanan.go — pesanan butuh SEDIKIT dari produk
type Katalog interface {
	Ambil(ctx context.Context, id int64) (produk.Produk, error)
}

type Layanan struct {
	simpan  Penyimpan
	katalog Katalog        // bukan *produk.Layanan
	jam     func() time.Time
}

func NewLayanan(s Penyimpan, k Katalog, opsi ...Opsi) *Layanan {
	l := &Layanan{simpan: s, katalog: k, jam: time.Now}
	for _, o := range opsi {
		o(l)
	}
	return l
}

Functional options untuk yang opsional

type Opsi func(*Layanan)

func DenganJam(f func() time.Time) Opsi {
	return func(l *Layanan) { l.jam = f }
}

func DenganBatasRetry(n int) Opsi {
	return func(l *Layanan) { l.retry = n }
}

// Wajib jadi parameter; opsional jadi opsi.
svc := pesanan.NewLayanan(repo, katalog,
	pesanan.DenganBatasRetry(5))

Go tidak punya parameter opsional maupun bernama, dan konstruktor dengan tujuh parameter cepat jadi tidak terbaca. Pola ini memberi keduanya, sambil menjaga dependensi wajib tetap wajib — sesuatu yang tidak bisa dilakukan struct konfigurasi biasa.

Kalau main sudah terlalu panjang

// Kelompokkan perakitan per area, tetap di satu berkas
type Aplikasi struct {
	Cfg    config.Config
	Log    *slog.Logger
	Pool   *pgxpool.Pool
	Produk *produk.Layanan
	Pesanan *pesanan.Layanan
}

func Rakit(ctx context.Context, cfg config.Config) (*Aplikasi, func(), error) {
	...
	tutup := func() {
		pool.Close()
		rdb.Close()
	}
	return &Aplikasi{...}, tutup, nil
}

Ringkasan aturan

1. Semua dependensi lewat konstruktor. Nol variabel paket yang bisa berubah.
2. Terima interface kecil, kembalikan struct konkret.
3. Interface dideklarasikan oleh pemakai, hanya berisi method yang benar-benar dipanggil.
4. Suntikkan waktu, keacakan, dan ID — semuanya sumber tes yang flaky.
5. Satu composition root, di cmd/<binari>/main.go.
6. Kembalikan fungsi penutup bersama objeknya, supaya main bisa defer.