Kako funkcionira injekcija ovisnosti u modernom PHP-u?

Question

Accepted Answer

**Dependency Injection (DI)** je uzor dizajna gdje klasa prima svoje ovisnosti spolja (obično preko konstruktora) umjesto da ih sama kreira. Moderni PHP okviri koriste DI intenzivno, često sa **spremištem** koje automatski razrješava i injektira ovisnosti — što rezultira labavo-povezanim, testabilnim kodom.

## Problem koji DI rješava

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

Injekcija ovisnosti (prema **sučelju**) odvaja klasu od konkretnih implementacija — možete zamijeniti implementacije i injektirati fake objekte u testovima.

## Injekcija kroz konstruktor (standardni oblik)

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

Injekcija kroz konstruktor čini ovisnosti eksplicitnim i osigurava da je objekt u potpunosti formiran kada se kreira.

## DI spremišta — automatska razrješba

```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 spremište** (u Laravel-u, Symfony-u ili samostalnom kao PHP-DI) automatski konstruira objekte razrješavajući njihove ovisnosti konstruktora rekurzivno — konfigurirate mapping sučelja-na-implementaciju, a spremište spaja sve zajedno.

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

## Zašto je važno

Injekcija ovisnosti je osnovni uzor u modernom PHP-u, centralan za način na koji su profesionalne aplikacije i okviri (Laravel, Symfony) strukturirani, pa je razumijevanje toga važno znanje na razini seniora.

Osnovnu vrijednost predstavljaju **odvajanje i testabilnost**: imajući da klase primaju svoje ovisnosti (deklarirane prema sučeljima) umjesto da ih kreiraju, kod postaje labavo povezan (ovisi o apstrakcijama, ne o konkretnim implementacijama), lako **testabilan** (injektirate fake objekte umjesto pravih baza podataka/servisa — čineći detaljno unit testiranje praktičnim) i fleksibilan (zamjena implementacija preko konfiguracije).

Moderni PHP okviri pružaju **DI spremišta** koja automatiziraju ovo — razrješavajući i injektirajući cijeli graf ovisnosti automatski na osnovi mappinga sučelja-na-implementaciju, pa ne trebate ručno konstruirati objekte.

Razumijevanje injekcije kroz konstruktor (standardni oblik), programiranje prema sučeljima i kako DI spremišta funkcioniraju (automatska razrješba) je neophodno za učinkovit rad sa PHP okvirima (koji su ugrađeni oko DI) i za pisanje dobro-arhitektuiranog, održivog, testabilnog koda.

Pošto DI predstavlja temelj strukture svih glavnih modernih PHP okvira i predstavlja obilježje profesionalnog dizajna aplikacija, savladavanje toga — uzora, njegovih prednosti i razrješbe temeljene na spremištu — je važno znanje koje razlikuje razvijače koji mogu graditi čist, testabilan, okvir-idiomatski PHP od onih koji pišu čvrsto-povezan, teško-testabilan kod.