Wat is dependency injection en hoe wordt het…

Afhankelijkheidsinjectie (DI) is een ontwerppatroon dat het mogelijk maakt dat een object afhankelijkheden verkrijgt van een ander object of framework, in plaats van ze zelf te creëren. Dit vergemakkelijkt het beheer van klasse-afhankelijkheden en maakt de code flexibeler, testbaarder en onderhoudbaarder.

In PHP wordt DI toegepast voor:

Het verminderen van koppeling: Klassen zijn niet strak gekoppeld aan specifieke implementaties van hun afhankelijkheden.
Het vereenvoudigen van unit tests: Het is gemakkelijk om echte afhankelijkheden te vervangen door mock-objecten voor tests.
Het vergroten van flexibiliteit en uitbreidbaarheid: Het is eenvoudig om implementaties van afhankelijkheden te wijzigen of te vervangen zonder de klasse die ze gebruikt te wijzigen.

Er zijn drie hoofdbenaderingen voor afhankelijkheidsinjectie:

Injectie via de constructor (Constructor Injection): Afhankelijkheden worden als argumenten aan de constructor van de klasse doorgegeven. Dit is de meest aanbevolen methode, omdat het de beschikbaarheid van de benodigde afhankelijkheden garandeert bij het creëren van het object.

<?php
class DatabaseConnection
{
    // Details van de databaseverbinding
}

class UserRepository
{
    private DatabaseConnection $db;

    public function __construct(DatabaseConnection $db)
    {
        $this->db = $db;
    }

    // Methoden van de repository
}

// Object maken met afhankelijkheidsinjectie
$db = new DatabaseConnection();
$userRepository = new UserRepository($db);

Injectie via de setter (Setter Injection): Afhankelijkheden worden geïnjecteerd via openbare setter-methoden. Dit maakt afhankelijkheden optioneel.

<?php
class Logger
{
    // Logging
}

class UserService
{
    private ?Logger $logger = null; // Optionele afhankelijkheid

    public function setLogger(Logger $logger): void
    {
        $this->logger = $logger;
    }

    public function doSomething(): void
    {
        if ($this->logger) {
            $this->logger->log("Iets doen...");
        }
        // Hoofdlus
    }
}

// Object maken en optionele afhankelijkheid injecteren
$userService = new UserService();
$logger = new Logger();
$userService->setLogger($logger);

Injectie via de interface (Interface Injection): De klasse die de afhankelijkheid nodig heeft, implementeert een interface die een methode definieert om deze afhankelijkheid in te stellen. Dit is minder gebruikelijk in PHP dan de eerste twee.

In echte PHP-toepassingen worden vaak Dependency Injection Containers gebruikt. Dit zijn bibliotheken of frameworks die het proces van het maken van objecten en hun afhankelijkheden automatiseren. De container kan de afhankelijkheden van een klasse analyseren en automatisch de benodigde objecten maken en injecteren.

Voorbeelden van populaire DI-containers voor PHP:

PHP-DI
Symfony\DependencyInjection
Laravel Service Container (in Laravel inbegrepen)

Gebruik van DI-container:

<?php
// Voorbeeld met een pseudo-container
// De container wordt meestal geconfigureerd via configuratiebestanden (YAML, PHP-arrays, enz.)

// Configuratie van de container (vereenvoudigd)
$container->set(DatabaseConnection::class, function() {
    return new DatabaseConnection(); // Object maken
});

$container->set(UserRepository::class, function($container) {
    // Injectie van afhankelijkheid DatabaseConnection bij het maken van UserRepository
    return new UserRepository($container->get(DatabaseConnection::class));
});

// Object uit de container halen - de container maakt en injecteert automatisch de afhankelijkheden
$userRepository = $container->get(UserRepository::class);

Kortom, afhankelijkheidsinjectie in PHP is een belangrijk patroon voor het bouwen van flexibele, testbare en onderhoudbare code, vooral in grote projecten en bij gebruik van frameworks.

Wat is dependency injection en hoe wordt het toegepast in PHP-ontwikkeling?