Aller au contenu principal

L'injection de dépendances

Notions théoriques​

L'injection de dépendances est un patron de conception qui permet de rendre nos applications plus modulaires, plus testables et plus maintenables.

Au lieu de créer des objets à l'intérieur d'une classe ou d'une méthode, nous les passons en tant que paramètres (on "injecte" les dépendances).

Dans notre jeu de combat, par exemple, nous pourrions avoir une classe Game qui dépend d'une classe Fighter. Au lieu de créer un objet Fighter à l'intérieur de la classe Game, nous pourrions le passer en paramètre à la méthode startGame.

Pourquoi utiliser l'injection de dépendances ?​

  1. Cela nous permet de changer les détails de ces objets sans avoir à modifier la classe ou la méthode qui les utilise.

Car elle se base sur le principe de l'inversion de contrôle.

  1. De plus, cela facilite les tests unitaires, car vous pouvez injecter des fausses données (mocks) pour tester la classe indépendamment de ses dépendances réelles.

Qu'est-ce que l'inversion de contrôle ?​

Cela signifie que ce n'est pas la classe qui contrôle comment et quand créer ses dépendances, mais c'est une entité externe (généralement un conteneur d'injection de dépendances) qui s'en charge.

Par exemple, disons que vous avez une classe Game qui utilise un objet Fighter. Si Game crée l'objet Fighter directement, alors chaque fois que vous voulez changer quelque chose sur Fighter (par exemple, changer les paramètres du constructeur), vous devez également modifier Game.

En revanche, si Game reçoit un objet Fighter par injection de dépendances (c'est-à-dire qu'un objet Fighter est passé au constructeur de Game), alors Game n'a pas besoin de savoir comment Fighter est créé. Cela signifie que vous pouvez changer Fighter comme vous le souhaitez, sans avoir à modifier Game.

astuce

L'injection de dépendances rend votre code plus flexible et plus facile à maintenir, car les modifications d'une partie du code n'entraînent pas nécessairement des modifications dans d'autres parties.

Exemple pratique​

class Fighter {
    public function attack() {
        // Code pour attaquer
    }
}

class Game {
    private $fighter;

    public function __construct(Fighter $fighter) {
        $this->fighter = $fighter;
    }

    public function startGame() {
        // Utiliser $this->fighter pour commencer le jeu
        $this->fighter->attack();
    }
}

Et maintenant, nous pouvons injecter un objet Fighter dans un objet Game comme ceci :

$fighter = new Fighter();
$game = new Game($fighter);
$game->startGame();

Test de mémorisation/compréhension​


Qu'est-ce que l'injection de dépendances en PHP ?


Pourquoi utiliser l'injection de dépendances ?


Comment injecter une dépendance dans une classe en PHP ?


Quel est l'avantage principal de l'injection de dépendances ?


Comment peut-on utiliser l'injection de dépendances dans notre jeu de combat ?


TP pour réfléchir et résoudre des problèmes​

Dans ce TP, vous allez mettre en pratique l'injection de dépendances dans notre jeu de combat :

  • Vous allez créer une nouvelle classe Arena qui aura une méthode openGates.
  • Ensuite, vous allez créer une classe Game qui reçoit un objet Arena en paramètre de son constructeur.

La classe Game doit avoir une méthode startGame qui utilise l'objet Arena pour commencer le jeu.

Voici les consignes détaillées pour réaliser le TP :

Étape 1 : Création de la classe Arena​

Dans cette étape, vous allez créer une classe Arena. Cette classe doit avoir une méthode openGates qui affiche le message "Les portes de l'arène s'ouvrent !".

Pour cela, suivez les étapes suivantes :

  1. Ouvrez votre éditeur de texte et créez un nouveau fichier PHP que vous nommerez Arena.php.
  2. Dans ce fichier, déclarez une nouvelle classe appelée Arena.
  3. Dans la classe Arena, définissez une méthode publique openGates.
  4. Dans la méthode openGates, utilisez la fonction echo pour afficher le message "Les portes de l'arène s'ouvrent !".

Votre fichier Arena.php devrait ressembler à ceci :

class Arena {
    public function openGates() {
        echo "Les portes de l'arène s'ouvrent !\n";
    }
}

Étape 2 : Création de la classe Game​

Dans cette étape, vous allez créer une classe Game qui reçoit un objet Arena en paramètre de son constructeur. La classe Game doit avoir une méthode startGame qui utilise l'objet Arena pour commencer le jeu.

Suivez ces étapes :

  1. Créez un nouveau fichier PHP que vous nommerez Game.php.
  2. Dans ce fichier, déclarez une nouvelle classe appelée Game.
  3. Dans la classe Game, définissez un propriété privé $arena.
  4. Définissez un constructeur qui prend un objet Arena en paramètre et l'assigne à la propriété $arena.
  5. Définissez une méthode publique startGame qui appelle la méthode openGates de l'objet Arena (la propriété privé $arena).

Étape 3 : Utiliser nos classes​

Maintenant que vous avez créé vos classes, il est temps de les utiliser.

  1. Créez un nouveau fichier PHP que vous nommerez main.php.
  2. Dans ce fichier, incluez les fichiers Arena.php et Game.php en utilisant la fonction include.
  3. Créez un nouvel objet Arena et un nouvel objet Game en passant l'objet Arena au constructeur de Game.
  4. Appelez la méthode startGame de l'objet Game.

Votre fichier main.php devrait ressembler à ceci :

// main.php
include 'Arena.php';
include 'Game.php';

$arena = new Arena();
$game = new Game($arena);
$game->startGame();

Maintenant, ouvrez votre terminal, naviguez jusqu'au dossier contenant votre fichier main.php et exécutez le fichier avec la commande php main.php.

Vous devriez voir le message "Les portes de l'arène s'ouvrent !" s'afficher dans la console.

Si c'est le cas, félicitations ! Vous avez réussi le TP.

Une solution