Co je to servisní kontejner a injektáž závislostí?

Question

Accepted Answer

**Servisní kontejner** (IoC kontejner) je jádrem Laravelu — spravuje **injektáž závislostí**, automaticky vyřešuje a injonuje závislosti tříd. Pouze si typově označíte, co potřebujete, a kontejner to zkonstruuje a poskytne vám, což umožňuje volně propojený a testovatelný kód.

## Automatická injektáž závislostí (běžný případ)

```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
    }
}
```

Kontejner čte typové nápovědy konstruktoru (a metod) a **automaticky konstruuje a injonuje** závislosti — vyřešuje jejich závislosti rekurzivně. Zřídka voláte `new` pro služby; kontejner všechno propojí.

## Vázání implementací na rozhraní

```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
}
```

Vázání **rozhraní na implementaci** vám umožní záviset na abstrakcích — a vyměňovat implementace (např. falešnou bránu v testech) beze změny kódu, který je používá.

## Singletony a ruční vyřešení

```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` registruje jednu sdílenou instanci; `app()`/`resolve()` načítají z kontejneru ručně.

## Proč na tom záleží

Servisní kontejner a injektáž závislostí jsou základem Laravelu — takto framework propojuje komponenty aplikace, a proto je jejich pochopení důležité pro efektivní práci s Laravelem a psaní dobře architektonického kódu.

**Automatická injektáž závislostí** kontejneru je všudypřítomná: typově označené závislosti v controllerech, jobech a dalších třídách jsou automaticky vyřešeny a injonány (konstruuje se celý graf závislostí), a proto zřídka instantujete služby ručně — to umožňuje čistý, volně propojený, testovatelný kód.

Schopnost **vázat rozhraní na implementace** je zvlášť důležitá: závisejte na abstrakcích (rozhraní) spíše než na konkrétních třídách, přičemž kontejner poskytuje implementaci, takže je kód flexibilní (vyměňujte implementace pomocí konfigurace) a vysoce **testovatelný** (injonujte mocky/falešné objekty v testech — hlavní výhoda).

Pochopení kontejneru (automatické vyřešení, vázání rozhraní, singletony), jak funguje DI v celém Laravelu a jak to umožňuje testovatelnost a volné propojení, je cenné vědomosti pro budování udržitelných aplikací a pro pochopení, jak sám Laravel funguje (jeho komponenty jsou všechny vyřešeny skrze kontejner).

Keďže servisní kontejner je základem celé architektury Laravelu — a zvládnutí DI je klíčové pro psaní čistého, testovatelného, rámci-idiomatického kódu — je to důležité vědomosti, které odlišuje vývojáře, kteří Laravel hluboce chápou a budují dobře strukturované aplikace, od těch, kteří píšou těsně propojený kód v neznalosti kontejneru pracujícího pod nimi.