Injection de dépendances en PHP : Guide complet avec exemples

Introduction à l'Injection de Dépendances en PHP

Le développement moderne en PHP est impensable sans les principes de conception orientée objet. L'un des modèles clés qui permet de construire des applications flexibles, testables et maintenables est Dependency Injection (DI) ou injection de dépendances.

L'essence du modèle est simple : au lieu de créer des objets dépendants à l'intérieur d'une classe, nous les passons (injectons) de l'extérieur. Cela change radicalement l'architecture de l'application, rendant les classes indépendantes des implémentations spécifiques et simplifiant leurs tests.

Dans cet article, nous allons voir ce qu'est l'Injection de Dépendances en PHP, quelles sont les différentes façons de l'implémenter, et comment utiliser les conteneurs DI pour automatiser le processus.

Le problème : pourquoi sans DI c'est mauvais ?

Prenons un exemple typique. La classe UserController est responsable du traitement des requêtes liées aux utilisateurs. Elle utilise une base de données via la classe MysqlDatabase :

<?php

class MysqlDatabase {    public function query(string $sql): array {        // ... connexion à MySQL et exécution de la requête        return [];    }}

class UserController {    private MysqlDatabase $database;

    public function __construct() {        // Liaison rigide à une implémentation spécifique        $this->database = new MysqlDatabase();    }

    public function listUsers(): array {        return $this->database->query('SELECT * FROM users');    }}

$controller = new UserController();

Quels sont les problèmes de ce code ?

• Couplage fort : UserController est rigidement lié à MysqlDatabase. Si nous voulons passer à PostgreSQL ou utiliser un stockage de fichiers, nous devons modifier le code du contrôleur.
• Difficulté de test : Vous ne pouvez pas remplacer la base de données par un objet mock dans les tests unitaires. Chaque test accédera à la base de données réelle, ce qui est lent et peu pratique.
• Violation du principe de responsabilité unique : Le contrôleur ne devrait pas savoir comment créer une connexion à la base de données. Sa tâche est de traiter les requêtes.

La solution à ce problème est d'appliquer le principe d'Inversion de Contrôle (IoC) et d'utiliser l'Injection de Dépendances.

Façons d'injecter des dépendances en PHP

Il existe trois façons principales d'injecter une dépendance dans une classe :

1. Injection par constructeur (Constructor Injection)

La méthode la plus courante et recommandée. La dépendance est passée via le paramètre du constructeur et est généralement stockée comme une propriété privée de la classe.

<?php

interface DatabaseInterface {    public function query(string $sql): array;}

class MysqlDatabase implements DatabaseInterface {    public function query(string $sql): array {        // Implémentation pour MySQL        return [];    }}

class PostgresDatabase implements DatabaseInterface {    public function query(string $sql): array {        // Implémentation pour PostgreSQL        return [];    }}

class UserController {    private DatabaseInterface $database;

    // La dépendance est injectée via le constructeur    public function __construct(DatabaseInterface $database) {        $this->database = $database;    }

    public function listUsers(): array {        return $this->database->query('SELECT * FROM users');    }}

// Utilisation$mysqlDb = new MysqlDatabase();$controller = new UserController($mysqlDb);

// Passage facile à une autre base de données$postgresDb = new PostgresDatabase();$controller2 = new UserController($postgresDb);

Avantages : La dépendance est clairement visible, l'objet est créé dans un état valide (la dépendance est obligatoire).

2. Injection par setters (Setter Injection)

Convient pour les dépendances optionnelles ou lorsque les dépendances