Kako deluje injekcija odvisnosti v sodobnem PHP-ju?

Question

Accepted Answer

**Dependency Injection (DI)** je oblikovalski vzorec, pri katerem razred prejme svoje odvisnosti iz zunaj (običajno preko konstruktorja) namesto da bi jih sam ustvaril. Sodobni PHP ogrodja uporabljajo DI intenzivno, pogosto s **kontejnerjem**, ki samodejno razrešuje in injicira odvisnosti — kar vodi do ohlapno povezane in testabilne kode.

## Problem, ki ga DI rešuje

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

Injiciranje odvisnosti (glede na **vmesnik**) odklanja razred od konkretnih implementacij — lahko zamenjate implementacije in vinjicirate mock-e v testih.

## Injekcija preko konstruktorja (standardna oblika)

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

Injekcija preko konstruktorja naredi odvisnosti eksplicitne in zagotovi, da je objekt v celoti oblikovan ob njegovem ustvarjanju.

## DI kontejnerji — samodajna razrešitev

```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-u, Symfony-ju ali samostojnem kot PHP-DI) samodejno konstruira objekte z razreševanjem njihovih odvisnosti konstruktorja rekurzivno — konfigurirate vezave vmesnikov na implementacije, in kontejner vse poveže skupaj.

## Prednosti

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

## Zakaj je to pomembno

Injekcija odvisnosti je temeljni vzorec v sodobnem PHP-ju, osrednjega pomena za to, kako so strukturirani profesionalni aplikacije in ogrodja (Laravel, Symfony), zato je razumevanje le-te pomembno znanje na ravni starejšega razvijalca.

Osrednja vrednost je **odklanjanje in testabilnost**: ker razredi prejemajo svoje odvisnosti (deklarirane glede na vmesnike) namesto da bi jih sami ustvarili, postane koda ohlapno povezana (odvisna od abstrakcij, ne konkretnih implementacij), enostavno **testabilna** (injicirate mock-e namesto resničnih podatkovnih baz/storitev — kar naredi temeljito testiranje enot praktično) in prožna (zamenjava implementacij prek konfiguracije).

Sodobna PHP ogrodja zagotavljajo **DI kontejnerje**, ki to avtomatizirajo — razreševanje in injiciranje celotnega grafa odvisnosti samodejno na podlagi vezav vmesnikov na implementacije, zato objektov ne morate ročno konstruirati.

Razumevanje injekcije preko konstruktorja (standardne oblike), programiranja glede na vmesnike in kako delujejo DI kontejnerji (samodajna razrešitev) je bistvenega pomena za učinkovito delo s PHP ogrodji (ki so zgrajena okrog DI) in za pisanje dobro strukturirane, vzdržljive, testabilne kode.

Ker DI podpira strukturo vseh glavnih sodobnih PHP ogrodij in je značilnost profesionalnega oblikovanja aplikacij, je obvladovanje le-te — vzorca, njegovih prednosti in razreševanja na podlagi kontejnerja — pomembno znanje, ki ločuje razvijalce, ki lahko gradijo čisto, testabilno, ogrodjem idealno prilagojeno PHP kodo, od tistih, ki pišejo tesno povezano, težko testabilno kodo.