Apa itu service container dan dependency injection?

Question

Accepted Answer

**Service container** (IoC container) adalah jantung Laravel — ia mengelola **dependency injection**, secara otomatis menyelesaikan dan menyuntikkan dependensi kelas. Anda mengetik apa yang Anda butuhkan, dan container membangun serta menyediakannya, memungkinkan kode yang longgar-terikat dan dapat diuji.

## Automatic dependency injection (kasus umum)

```php
class OrderController extends Controller {
    // type-hinted dependencies are AUTO-RESOLVED by the container — no manual `new`
    public function __construct(
        private OrderService $orders,
        private PaymentGateway $payments,
    ) {}

public function store(Request $request, Mailer $mailer) {
        // $request and $mailer also auto-injected into the method
    }
}
```

Container membaca type-hint konstruktor (dan metode) dan **secara otomatis membangun dan menyuntikkan** dependensi — menyelesaikan dependensi mereka secara rekursif. Anda jarang memanggil `new` untuk layanan; container menghubungkan semuanya.

## Binding implementasi ke interface

```php
// in a service provider — tell the container which implementation to use for an interface
$this->app->bind(PaymentGateway::class, StripeGateway::class);

// now anything type-hinting PaymentGateway gets a StripeGateway
class OrderService {
    public function __construct(private PaymentGateway $gateway) {}   // gets StripeGateway
}
```

Binding sebuah **interface ke implementasi** memungkinkan Anda bergantung pada abstraksi — dan menukar implementasi (misalnya gateway palsu dalam tes) tanpa mengubah kode yang mengonsumsi.

## Singletons dan resolusi manual

```php
$this->app->singleton(Cache::class, fn() => new RedisCache());   // ONE shared instance

// manual resolution (rarely needed — DI is preferred)
$service = app(OrderService::class);
$service = resolve(PaymentGateway::class);
```

`singleton` mendaftarkan instance bersama tunggal; `app()`/`resolve()` mengambil dari container secara manual.

## Mengapa ini penting

Service container dan dependency injection adalah fondasi Laravel — inilah cara framework menghubungkan komponen aplikasi, jadi memahami mereka penting untuk bekerja secara efektif dengan Laravel dan menulis kode yang dirancang dengan baik.

**Automatic dependency injection** container tersebar luas: dependensi yang di-type-hint dalam controller, job, dan kelas lainnya diselesaikan dan disuntikkan secara otomatis (membangun seluruh dependency graph), itulah mengapa Anda jarang membuat instance layanan secara manual — ini memungkinkan kode yang bersih, longgar-terikat, dan dapat diuji.

Kemampuan untuk **bind interface ke implementasi** sangat penting: bergantung pada abstraksi (interface) daripada kelas konkret, dengan container menyediakan implementasi, membuat kode fleksibel (menukar implementasi melalui konfigurasi) dan sangat **dapat diuji** (suntikkan mock/fake dalam tes — manfaat utama).

Memahami container (resolusi otomatis, interface binding, singleton), bagaimana DI bekerja di seluruh Laravel, dan bagaimana ia memungkinkan testabilitas dan loose coupling adalah pengetahuan berharga untuk membangun aplikasi yang dapat dirawat dan memahami cara Laravel beroperasi (komponen-komponennya semua diselesaikan melalui container).

Karena service container mendasari seluruh arsitektur Laravel — dan menguasai DI adalah kunci untuk menulis kode yang bersih, dapat diuji, dan idiomatic framework — ini adalah pengetahuan penting yang membedakan developer yang memahami Laravel secara mendalam dan membangun aplikasi yang terstruktur dengan baik dari mereka yang menulis kode tightly-coupled tanpa menyadari container yang bekerja di bawah mereka.