Hvordan fungerer dependency injection i moderne PHP?

Question

Accepted Answer

**Dependency Injection (DI)** er et designmønster, hvor en klasse modtager sine afhængigheder udefra (typisk via konstruktøren) i stedet for at oprette dem selv. Moderne PHP-frameworks bruger DI intensivt, ofte med en **container**, der automatisk løser og injicerer afhængigheder — hvilket fører til løst koblet, testbar kode.

## Problemet som DI løser

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

Injicering af afhængigheder (mod et **interface**) afkobler klassen fra konkrete implementeringer — du kan udskifte implementeringer og injicere mocks i tests.

## Constructor injection (standardformen)

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

Constructor injection gør afhængigheder eksplicitte og sikrer, at objektet er fuldt dannet, når det oprettes.

## DI containers — automatisk opløsning

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

En **DI container** (i Laravel, Symfony eller en standalone som PHP-DI) konstruerer automatisk objekter ved at løse deres constructor-afhængigheder rekursivt — du konfigurerer interface-til-implementering-bindinger, og containeren forbinder alt sammen.

## Fordelene

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

## Hvorfor det betyder noget

Dependency injection er et grundlæggende mønster i moderne PHP, centralt for hvordan professionelle applikationer og frameworks (Laravel, Symfony) er struktureret, så det er vigtig viden på seniorplan.

Kernekvaliteten er **afkobling og testbarhed**: ved at lade klasser modtage deres afhængigheder (deklareret mod interfaces) i stedet for at oprette dem, bliver koden løst koblet (afhængig af abstraktioner, ikke konkrete implementeringer), let **testbar** (du injicerer mocks i stedet for rigtige databaser/services — hvilket gør grundig unit testing praktisk) og fleksibel (udskiftning af implementeringer via konfiguration).

Moderne PHP-frameworks tilbyder **DI containers**, der automatiserer dette — opløsning og injicering af hele dependency graph automatisk baseret på interface-til-implementering-bindinger, så du ikke manuelt skal konstruere objekter.

Forståelse af constructor injection (standardformen), programmering mod interfaces og hvordan DI containers fungerer (automatisk opløsning) er væsentligt for at arbejde effektivt med PHP-frameworks (som er bygget omkring DI) og for at skrive velarkitektureret, vedligeholdelig, testbar kode.

Da DI ligger til grund for strukturen i alle større moderne PHP-frameworks og er kendetegn på professionel applikationsdesign, er det vigtig viden at mestre — mønsteret, dets fordele og container-baseret opløsning — som skelner udviklere, der kan bygge ren, testbar, framework-idiomatisk PHP fra dem, der skriver tæt koblet, svær-at-teste kode.