Jak funguje vkládání závislostí (dependency injection) v moderním PHP?

Question

Accepted Answer

**Dependency Injection (DI)** je návrhový vzor, kde třída obdrží své závislosti zvnějšku (typicky přes konstruktor) místo toho, aby je vytvářela sama. Moderní PHP frameworky používají DI intenzivně, často s **kontejnerem**, který automaticky rozpouští a vkládá závislosti — což vede k volně vázanému, testovatelném kódu.

## Problém, který DI řeší

```php
// ❌ tight coupling — the class CREATES its own dependencies (hard to test/swap)
class UserService {
    private $mailer;
    public function __construct() {
        $this->mailer = new SmtpMailer();   // hardcoded → can't mock, can't swap
    }
}

// ✅ dependency injection — dependencies are PASSED IN
class UserService {
    public function __construct(private MailerInterface $mailer) {}
    // depends on an INTERFACE, receives the concrete impl from outside
}
```

Vkládání závislostí (proti **rozhraní**) odtrhuje třídu od konkrétních implementací — můžete vyměňovat implementace a vkládat mockovaní objekty v testech.

## Vkládání přes konstruktor (standardní forma)

```php
class OrderService {
    public function __construct(
        private OrderRepository $repo,        // dependencies declared in the constructor
        private MailerInterface $mailer,
        private LoggerInterface $logger,
    ) {}
}
```

Vkládání přes konstruktor činí závislosti explicitními a zajišťuje, že je objekt plně vytvořen při inicializaci.

## DI kontejnery — automatické rozpouštění

```php
// a DI CONTAINER builds objects, resolving the whole dependency graph automatically
$container->bind(MailerInterface::class, SmtpMailer::class);   // map interface → impl

$service = $container->get(OrderService::class);
// the container sees OrderService needs OrderRepository, MailerInterface, LoggerInterface,
// constructs each (recursively), and injects them — you don't `new` anything manually
```

**DI kontejner** (v Laravel, Symfony, nebo samostatný jako PHP-DI) automaticky konstruuje objekty rozpouštěním jejich konstruktorových závislostí rekurzivně — nakonfigurujete vazby rozhraní-na-implementaci a kontejner všechno propojí.

## Výhody

```text
✓ Loose coupling — depend on interfaces/abstractions, not concrete classes
✓ Testability — inject mocks/fakes in tests (no real DB/mailer needed)
✓ Flexibility — swap implementations via container config (e.g. fake mailer in dev)
✓ Single responsibility — classes focus on logic, not constructing dependencies
```

## Proč to je důležité

Vkládání závislostí je fundamentální vzor v moderním PHP, ústředním pro to, jak jsou strukturovány profesionální aplikace a frameworky (Laravel, Symfony), takže jeho pochopení je důležité znalostí na seniorské úrovni.

Jádní hodnota je **rozpojení a testovatelnost**: tím, že třídy obdrží své závislosti (deklarované proti rozhraním) místo jejich vytváření, kód se stává volně vázaný (závisí na abstrakcích, ne na konkrétních implementacích), snadno **testovatelný** (vkládáte mockované objekty místo skutečných databází/služeb — díky čemuž je praktické důkladné testování jednotek) a flexibilní (vyměňování implementací přes konfiguraci).

Moderní PHP frameworky poskytují **DI kontejnery**, které toto automatizují — rozpouští a vkládají celý graf závislostí automaticky na základě vazeb rozhraní-na-implementaci, takže nemusíte ručně konstruovat objekty.

Pochopení vkládání přes konstruktor (standardní forma), programování proti rozhraním a toho, jak DI kontejnery fungují (automatické rozpouštění) je nezbytné pro efektivní práci s PHP frameworky (které jsou postaveny kolem DI) a pro psaní dobře strukturovaného, udržovatelného, testovatelného kódu.

Proto, že DI je základem struktury všech hlavních moderních PHP frameworků a je charakteristikou profesionálního návrhu aplikací, jejich zvládnutí — vzoru, jeho výhod a rozpouštění na bázi kontejneru — je důležitá znalost, která odlišuje vývojáře, kteří umí stavět čisté, testovatelné, framework-idiomatické PHP od těch, kteří píší těsně vázaný, těžko testovatelný kód.