Hoe werkt dependency injection in modern PHP?

Question

Accepted Answer

**Dependency Injection (DI)** is een design pattern waarbij een klasse haar dependencies van buiten ontvangt (meestal via de constructor) in plaats van ze zelf aan te maken. Moderne PHP frameworks gebruiken DI intensief, vaak met een **container** die dependencies automatisch oplost en injecteert — wat leidt tot losjes gekoppelde, testbare code.

## Het probleem dat DI oplost

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

Dependencies injecteren (tegen een **interface**) ontkoppelt de klasse van concrete implementaties — je kunt implementaties omwisselen en mocks in tests injecteren.

## Constructor injection (de standaardvorm)

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

Constructor injection maakt dependencies expliciet en zorgt ervoor dat het object volledig gevormd is wanneer het wordt aangemaakt.

## DI containers — automatische resolutie

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

Een **DI container** (in Laravel, Symfony, of een standalone zoals PHP-DI) construeert objecten automatisch door hun constructor dependencies recursief op te lossen — je configureert interface-naar-implementatie bindingen, en de container verbindt alles samen.

## De voordelen

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

## Waarom het belangrijk is

Dependency injection is een fundamenteel pattern in modern PHP, centraal aan hoe professionele applicaties en frameworks (Laravel, Symfony) zijn gestructureerd, dus het begrijpen ervan is belangrijk kennismateriaal op senior niveau.

De kernwaarde is **ontkoppeling en testbaarheid**: doordat klassen hun dependencies ontvangen (gedeclareerd tegen interfaces) in plaats van ze aan te maken, wordt code losjes gekoppeld (afhankelijk van abstracties, niet concrete implementaties), gemakkelijk **testbaar** (je injecteert mocks in plaats van echte databases/services — waardoor grondige unit testing praktisch wordt), en flexibel (implementaties omwisselen via configuratie).

Moderne PHP frameworks bieden **DI containers** die dit automatiseren — het hele dependency graph automatisch oplossen en injecteren op basis van interface-naar-implementatie bindingen, zodat je objecten niet handmatig hoeft aan te maken.

Constructor injection begrijpen (de standaardvorm), programmeren tegen interfaces, en hoe DI containers werken (automatische resolutie) is essentieel voor effectief werken met PHP frameworks (die rond DI zijn gebouwd) en voor het schrijven van goed architectuur, onderhoudbare, testbare code.

Omdat DI de structuur van alle grote moderne PHP frameworks ondersteunt en een kenmerk van professioneel applicatieontwerp is, het beheersen ervan — het pattern, de voordelen ervan, en container-gebaseerde resolutie — is belangrijke kennis die ontwikkelaars onderscheidt die schone, testbare, framework-idiomatische PHP kunnen bouwen van degenen die losjes gekoppelde, moeilijk-te-testen code schrijven.