Injection de dépendances

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 57 sur 91.

Dans la leçon précédente, vous avez vu comment la composition permet à une Car de contenir un objet Engine. Mais il y a un problème avec la création de dépendances à l'intérieur de la classe - cela rend le code rigide et difficile à tester. L'injection de dépendances résout ce problème en passant les dépendances de l'extérieur plutôt qu'en les créant en interne.

Comparez ces deux approches :

<?php
// Sans DI - dépendance créée à l'intérieur
class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine(); // Fortement couplé
    }
}

// Avec DI - dépendance transmise
class Car {
    public function __construct(private Engine $engine) {}
}

$engine = new Engine();
$car = new Car($engine); // Injecté de l'extérieur

La deuxième approche est l'injection de dépendances. La Car ne crée pas son propre moteur - elle en reçoit un. Ce simple changement présente des avantages puissants : vous pouvez passer différents types de moteurs, échanger les implémentations pour les tests, et la classe devient plus flexible.

Pour encore plus de flexibilité, injectez des interfaces au lieu de classes concrètes :

<?php
interface EngineInterface {
    public function start(): string;
}

class Car {
    public function __construct(private EngineInterface $engine) {}
    
    public function start(): string {
        return $this->engine->start();
    }
}

Maintenant, Car fonctionne avec n'importe quelle classe implémentant EngineInterface - un moteur à essence, un moteur électrique ou un mock pour les tests. Ce découplage est la raison pour laquelle l'injection de dépendances est fondamentale pour écrire des applications PHP maintenables et testables.

Défi

Facile

Construisons un système de notification qui démontre la puissance de l'injection de dépendances. Au lieu de coder en dur la manière dont les messages sont envoyés, vous allez créer un système flexible où la méthode de distribution peut être remplacée facilement.

Vous organiserez votre code sur quatre fichiers :

MessageSenderInterface.php — Définissez une interface nommée MessageSenderInterface avec une seule méthode send(string $recipient, string $message): string. Cette interface établit le contrat que tout expéditeur de message doit suivre.
EmailSender.php — Créez une classe EmailSender qui implémente MessageSenderInterface. Incluez le fichier de l'interface. La méthode send() doit retourner "Email to $recipient: $message".
NotificationService.php — Créez une classe NotificationService qui reçoit sa dépendance via le constructeur. Incluez le fichier de l'interface. La classe doit :
- Accepter un MessageSenderInterface dans son constructeur en utilisant la promotion de propriété de constructeur
- Avoir une méthode notify(string $recipient, string $message) qui délègue à l'expéditeur injecté et retourne son résultat
Remarquez comment NotificationService dépend de l'interface, et non d'une classe concrète. Cela signifie que vous pourriez injecter n'importe quel expéditeur implémentant l'interface sans modifier le service.
main.php — Incluez les fichiers EmailSender et NotificationService. Vous recevrez deux entrées : un destinataire et un message. Créez un EmailSender, injectez-le dans un NotificationService, puis appelez notify() et affichez le résultat.

Ce modèle maintient votre NotificationService flexible — il fonctionne avec n'importe quel expéditeur que vous injectez, qu'il s'agisse d'un e-mail, d'un SMS ou de quelque chose que vous n'avez pas encore construit. Le service ne crée pas ses propres dépendances ; il les reçoit de l'extérieur.

Aide-mémoire

L'injection de dépendances (DI) est une technique où les dépendances sont transmises à une classe de l'extérieur plutôt que d'être créées en interne.

Sans DI (fortement couplé) :

<?php
class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine(); // Créé à l'intérieur
    }
}

Avec DI (faiblement couplé) :

<?php
class Car {
    public function __construct(private Engine $engine) {}
}

$engine = new Engine();
$car = new Car($engine); // Injecté de l'extérieur

Pour une flexibilité maximale, injectez des interfaces au lieu de classes concrètes :

<?php
interface EngineInterface {
    public function start(): string;
}

class Car {
    public function __construct(private EngineInterface $engine) {}
    
    public function start(): string {
        return $this->engine->start();
    }
}

Cela permet à Car de fonctionner avec n'importe quelle classe implémentant EngineInterface, rendant le code plus facile à maintenir et à tester.

Essayez vous-même

<?php
require_once 'EmailSender.php';
require_once 'NotificationService.php';

// Lire l'entrée
$recipient = trim(fgets(STDIN));
$message = trim(fgets(STDIN));

// TODO : Créer une instance de EmailSender
// TODO : L'injecter dans un NotificationService
// TODO : Appeler notify() et afficher le résultat

?>