Injection de Dépendances en TypeScript : un guide simple pour débutants

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

Dans le monde du développement logiciel, nous rencontrons souvent des situations où une classe (ou un module) dépend d'une autre. Par exemple, une classe UserService peut utiliser une classe DatabaseService pour sauvegarder des données. L'approche traditionnelle consiste à créer une instance de DatabaseService directement à l'intérieur de UserService. Cela conduit à un couplage fort du code, ce qui complique les tests, la maintenance et l'extension.

L'Injection de Dépendances (DI) est un patron de conception qui résout ce problème. Au lieu de créer les dépendances à l'intérieur de la classe, elles sont « injectées » de l'extérieur. Cela met en œuvre le principe d'Inversion de Contrôle (IoC) : ce n'est pas la classe qui gère ses dépendances, mais le code externe (conteneur ou appelant) qui les fournit.

Dans cet article, nous allons voir comment implémenter l'Injection de Dépendances en TypeScript avec des exemples simples. Vous apprendrez pourquoi DI est considérée comme une bonne pratique et comment elle aide à écrire un code propre et testable.

Le problème : Couplage fort sans DI

Commençons par un exemple qui montre comment ne pas écrire de code. Imaginez que nous avons une application qui envoie des notifications aux utilisateurs.

// Sans Injection de Dépendancesclass EmailService {    sendEmail(to: string, message: string): void {        console.log(`Envoi d'email à ${to} : ${message}`);        // ... logique réelle d'envoi    }}

class NotificationService {    private emailService: EmailService;

    constructor() {        // Problème : couplage fort        this.emailService = new EmailService();    }

    notifyUser(userEmail: string, message: string): void {        this.emailService.sendEmail(userEmail, message);    }}

// Utilisationconst notifier = new NotificationService();notifier.notifyUser('user@example.com', 'Bonjour !');

Dans ce code, NotificationService est fortement couplé à EmailService. Que faire si nous voulons envoyer des SMS ou des notifications push ? Il faudrait modifier le code de NotificationService. De plus, tester NotificationService est difficile — nous ne pouvons pas remplacer le vrai EmailService par un objet mock.

Solution : Injection de dépendances via le constructeur

La manière la plus simple et la plus courante d'implémenter DI est de passer les dépendances via le constructeur. Cela rend le code flexible et facilement testable.

D'abord, définissons une interface pour notre service de notifications. C'est une étape clé : nous programmons au niveau des abstractions, et non des implémentations concrètes.

// Définition d'une interface pour tout service de notificationsinterface INotificationService {    send(to: string, message: string): void;}

// Implémentation pour Emailclass EmailService implements INotificationService {    send(to: string, message: string): void {        console.log(`[EMAIL] Envoyé à ${to} : ${message}`);    }}

// Implémentation pour SMSclass SMSService implements INotificationService {    send(to: string, message: string): void {        console.log(`[SMS] Envoyé à ${to} : ${message}`);    }}

// Classe qui utilise DIclass UserNotifier {    private notifier: INotificationService;

    // La dépendance est injectée via le constructeur    constructor(notifier: INotificationService) {        this.notifier = notifier;    }

    notifyUser(userContact: string, message: string): void {        this.notifier.send(userContact, message);    }}

// Utilisationconst emailNotifier = new UserNotifier(new EmailService());emailNotifier.notifyUser('alice@example.com', 'Votre commande est prête !');

const smsNotifier = new UserNotifier(new SMSService());smsNotifier.notifyUser('+7-999-123-45-67', 'Code de confirmation : 1234');

Maintenant, UserNotifier ne sait pas quel service est utilisé exactement