L'injection de dépendances

Petite vérification

Avant de commencer, vérifiez si vous savez...

1. compléter la méthode getInstance() du pattern Singleton : if (null === self::$instance) { ___ } — écrire l'instruction qui crée l'instance et l'affecte à self::$instance
2. expliquer pourquoi le constructeur de la classe GameConfig (pattern Singleton) doit être déclaré private
3. expliquer le rôle du design pattern Factory, illustré par la classe CharacterFactory

📌 Réponse attendue

Vous devez être connecté pour voir le contenu.

Email : Mot de passe :

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.

2. 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 ?

C'est une technique qui consiste à passer des objets en paramètres à une classe ou une méthode.

C'est une technique qui consiste à créer des objets à l'intérieur d'une classe ou d'une méthode.

C'est une technique qui consiste à utiliser des variables globales pour partager des objets entre différentes parties de l'application.

Pourquoi utiliser l'injection de dépendances ?

Pour rendre l'application plus difficile à comprendre par les hackers qui veulent pirater les utilisateurs.

Pour augmenter le couplage entre différentes parties de l'application.

Pour rendre l'application plus modulaire, plus testable et plus maintenable.

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

En créant l'objet à l'intérieur de la classe, par exemple : $fighter = new Fighter($parameter1).

En utilisant une variable globale pour stocker l'objet.

En passant l'objet en paramètre au constructeur de la classe.

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

Elle permet de réduire la modularité de l'application en réduisant le mnombre de modules utilisés dans l'application.

Elle permet de réduire la testabilité (tests unitaires et tests fonctionnels) de l'application Web ou mobile.

Elle permet de changer les détails des objets sans avoir à modifier la classe ou la méthode qui les utilise.

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

En créant un objet `Fighter` à l'intérieur de la classe `Game`, par exemple : $fighter = new Fighter($parameter1).

En utilisant une variable globale pour stocker l'objet `Fighter`.

En passant un objet `Fighter` en paramètre à la méthode `startGame` de la classe `Game`.

---

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.

Bonne pratique - Injection de dépendances

Injecter les dépendances via le constructeur plutôt que de les créer à l'intérieur de la classe (new Arena() dans Game). Cela permet de remplacer facilement Arena par un mock dans les tests, et de changer d'implémentation sans modifier Game. Principe : "ne pas chercher ce dont on a besoin, le recevoir".

📌 Une solution

Vous devez être connecté pour voir le contenu.

Email : Mot de passe :