Injection de Dépendances en JavaScript : Guide Complet avec Exemples

Injection de Dépendances en JavaScript : Guide Complet

L'Injection de Dépendances (DI) est un puissant patron de conception qui est au cœur du principe d'Inversion de Contrôle (IoC). Au lieu qu'un objet crée lui-même ses dépendances, la DI les « injecte » de l'extérieur. Cela rend le code plus flexible, testable et maintenable. Dans cet article, nous allons voir comment implémenter l'Injection de Dépendances en JavaScript et Node.js, en utilisant des exemples simples et clairs.

Qu'est-ce que l'Injection de Dépendances et pourquoi en a-t-on besoin ?

Imaginez que vous ayez une classe UserService qui interagit avec une base de données. Sans DI, vous créeriez très probablement une instance de la base de données directement à l'intérieur du service :

class UserService {  constructor() {    this.db = new Database(); // Couplage fort  }

  getUser(id) {    return this.db.findUser(id);  }}

Ce code viole le Principe d'Inversion des Dépendances (Dependency Inversion Principle). Lors du test de UserService, vous ne pourrez pas remplacer la vraie base de données par un objet mock sans modifier le code de la classe. La DI résout ce problème :

class UserService {  constructor(database) {    this.db = database; // La dépendance est passée de l'extérieur  }

  getUser(id) {    return this.db.findUser(id);  }}

// Utilisationconst db = new Database();const userService = new UserService(db);

Principaux avantages de la DI :

• Testabilité : Il est facile de remplacer les dépendances par des mocks ou des stubs.
• Faible couplage : Les classes dépendent d'abstractions (interfaces), et non d'implémentations concrètes.
• Flexibilité : On peut facilement changer le comportement du système en remplaçant les implémentations.
• Réutilisabilité du code : Les composants deviennent indépendants et peuvent être utilisés dans différents contextes.

Méthodes d'injection de dépendances en JavaScript

En JavaScript, il existe trois méthodes principales pour injecter des dépendances :

1. Injection par le constructeur (Constructor Injection)

La méthode la plus courante et recommandée. Les dépendances sont passées au moment de la création de l'objet.

class Logger {  log(message) {    console.log(`[LOG]: ${message}`);  }}

class OrderService {  constructor(logger) {    this.logger = logger;  }

  createOrder(data) {    this.logger.log('Nouvelle commande créée');    // Logique de création de commande  }}

const logger = new Logger();const orderService = new OrderService(logger);orderService.createOrder({ product: 'Laptop', price: 1500 });

2. Injection par les setters (Setter Injection)

Les dépendances sont définies après la création de l'objet via des méthodes setters. Convient pour les dépendances optionnelles.

class EmailService {  constructor() {    this.transporter = null;  }

  setTransporter(transporter) {    this.transporter = transporter;  }

  send(email) {    if (!this.transporter) {      throw new Error('Transporter non défini');    }    this.transporter.sendMail(email);  }}

const emailService = new EmailService();emailService.setTransporter(someMailTransporter);

3. Injection par interface (Interface Injection — conditionnellement)

JavaScript n'a pas d'interfaces natives, mais on peut utiliser TypeScript ou la documentation pour décrire les contrats. En pratique, cela revient à vérifier la présence de méthodes.

Création d'un conteneur DI simple en Node.js

Pour gérer les dépendances dans les grandes applications, il est pratique d'utiliser un conteneur DI. Il stocke toutes les dépendances et les résout automatiquement. Voici une implémentation minimale :

class Container {  constructor() {    this.services = new Map();    this.singletons = new Map();  }

  // Enregistrement d'une fabrique pour un service  register(name,