Kaip veikia priklausomybės injekcija šiuolaikiniame PHP?

Question

Accepted Answer

**Dependency Injection (DI)** yra projektavimo šablonas, kuriame klasė gauna savo priklausomybes iš išorės (paprastai per konstruktorių) užuot jas pati kurusi. Šiuolaikiniuose PHP karkluose DI naudojamas dažnai, dažnai su **konteineriu**, kuris automatiškai išsprendžia ir injecina priklausomybes — vedant prie laisvai susietų, testuojamų kodų.

## Problema, kurią DI sprendžia

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

Injekcijuojant priklausomybes (prieš **sąsają**) atskiriami klasės nuo konkrečių implementacijų — galite pakeisti implementacijas ir injected mock'us testuose.

## Konstruktoriaus injekcija (standartinė forma)

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

Konstruktoriaus injekcija daro priklausomybes aiškias ir užtikrina, kad objektas yra visapusiškai suformuotas, kai jis sukurtas.

## DI konteineriai — automatinis išsprendimas

```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 konteineris** (Laravel, Symfony arba atskirus kaip PHP-DI) automatiškai konstruoja objektus išsprendžiant jų konstruktoriaus priklausomybes rekursyviai — jūs konfigūruojate sąsajos-į-implementaciją susiejimus, ir konteineris sujungia viską kartu.

## Privalumai

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

## Kodėl tai svarbu

Dependency Injection yra pagrindinė šiuolaikinio PHP šablonas, centrinė, kaip profesionalios aplikacijos ir karkluai (Laravel, Symfony) yra sustruktūrizuoti, todėl jo supratimas yra svarbus aukšto lygio žinios.

Pagrindinė vertė yra **atskyrimas ir testuojamumas**: todėl kad klasės gauna savo priklausomybes (deklaruotas prieš sąsajas) užuot jas kurusi, kodas tampa laisvai susietas (priklausomas nuo abstrakcijų, ne konkrečių implementacijų), lengvai **testuojamas** (jūs injektuojate mock'us vietoj tikrų duomenų bazių/tarnybų — todėl nuodugnūs vienetiniai testai praktiškai įmanomi), ir lanksčiai (keičiant implementacijas per konfigūraciją).

Šiuolaikiniuose PHP karkluose yra **DI konteineriai**, kurie tai automatizuoja — išsprendžiant ir injektuojant visą priklausomybių grafiką automatiškai pagal sąsajos-į-implementaciją susiejimus, todėl jums nereikia rankiniu būdu konstruoti objektus.

Supratimas konstruktoriaus injekcijos (standartinė forma), programavimo prieš sąsajas ir kaip DI konteineriai veikia (automatinis išsprendimas) yra gyvybiškai svarbus darbui efektyviai su PHP karkluais (kurie yra pagrįsti DI) ir rašymui gerai architektūrizuoto, palaikomos, testuojamo kodo.

Kadangi DI nustato visų pagrindinių šiuolaikinių PHP karkluų struktūrą ir yra profesionalaus aplikacijos projektavimo ženklas, jį savaldyti — šabloną, jo privalumus ir konteinerio pagrindu atliekamą išsprendimą — yra svarbi žinios, kuri skiria kūrėjus, kurie gali kurti šviesų, testuojamą, karklo idiomatinį PHP iš tų, kurie rašo tiesiai susietą, sunkiai testuojamą kodą.