Apa iku service container lan dependency injection?

Question

Accepted Answer

The **service container** (IoC container) iku jantung Laravel — iku ngatur **dependency injection**, otomatis ngresolve lan nyuntikke class dependencies. Sampeyan type-hint apa sing sampeyan butuh, lan container ngo-konstruksi lan nyediakke, ngaktifake loosely-coupled, testable code.

## 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 maca constructor (lan method) type-hints lan **otomatis ngo-konstruksi lan nyuntikke** dependencies — ngresolve depensi-depensi recursively. Sampeyan arang manggil `new` kanggo services; container neng-wire kabeh barang.

## Binding implementations kanggo interfaces

```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 **interface menyang implementation** ngungkuli sampeyan gumantung ing abstractions — lan swap implementations (cth. fake gateway ing tests) tanpa ngowah consuming code.

## Singletons lan ngresolve 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` ndaftar siji shared instance; `app()`/`resolve()` njemput saking container manual.

## Apa iku penting

Service container lan dependency injection iku foundational kanggo Laravel — iki carane framework neng-wire babar aplikasi components, mula ngerti-ngerti iku penting kanggo makarya efektif karo Laravel lan nulis well-architected code.

Automatic dependency injection container iku pervasive: type-hinted dependencies ing controllers, jobs, lan class liyane diresove lan diinjeksi otomatis (ngo-konstruksi wulan dependency graph), mula sampeyan arang instantiate services manual — iki ngaktifake clean, loosely-coupled, testable code.

Kemampuan kanggo **bind interfaces menyang implementations** iku khusus penting: gumantung ing abstractions (interfaces) tinimbang concrete classes, karo container nyediakke implementation, nggawe code flexible (swap implementations via configuration) lan highly **testable** (inject mocks/fakes ing tests — benefit major).

Ngerti container (automatic resolution, interface binding, singletons), carane DI makarya throughout Laravel, lan carane iku ngaktifake testability lan loose coupling iku valuable knowledge kanggo mbangun maintainable applications lan kanggo ngerti carane Laravel dhewe makarya (components-components iku kabeh diresolve through container).

Kamangka service container ngalas Laravel sapratelan architecture — lan mastering DI iku key kanggo nulis clean, testable, framework-idiomatic code — iku important knowledge sing ngbedakke developers sing ngerti Laravel deeply lan mbangun well-structured applications saking sing nulis tightly-coupled code tanpa ngerti container makarya ngisor-ngisor iku.