Injection de dépendances (Dependency Injection) en Java : guide complet

Introduction : qu'est-ce que l'injection de dépendances et pourquoi en a-t-on besoin en Java

Dans le développement Java moderne, la propreté du code et sa testabilité sont des exigences clés pour un professionnel. Dependency Injection (DI), ou injection de dépendances, est un patron de conception qui permet de rendre votre code faiblement couplé, flexible et facile à maintenir. Au lieu que l'objet crée lui-même ses dépendances (par exemple via new), le DI les « injecte » de l'extérieur. C'est une partie fondamentale du principe d'Inversion de contrôle (IoC).

Dans cet article, nous analyserons comment fonctionne l'injection de dépendances en Java, examinerons les trois principales façons de l'implémenter (via le constructeur, les setters et l'interface) et montrerons comment le DI est utilisé dans des projets réels, y compris le framework populaire Spring.

Pourquoi sans DI votre code devient fragile ?

Imaginez une classe Car qui crée un moteur en son sein :

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new PetrolEngine(); // Couplage fort
    }

    public void start() {
        engine.run();
    }
}

Les problèmes de cette approche sont évidents :

• Impossibilité de réutilisation : Vous ne pourrez pas facilement remplacer PetrolEngine par ElectricEngine.
• Difficulté de test : Pour les tests unitaires, vous devrez créer un vrai moteur, et non un simulacre (mock).
• Violation du SRP : La classe Car ne se contente pas de gérer la voiture, mais aussi de créer le moteur.

L'injection de dépendances résout ces problèmes en déléguant la création des dépendances à un code externe (conteneur ou autre classe).

Trois façons d'injecter des dépendances en Java

En Java, il existe trois approches principales pour implémenter le DI. Examinons chacune d'elles avec un exemple de système de notifications.

1. Injection par constructeur (Constructor Injection)

C'est la méthode la plus préférée. Les dépendances sont transmises via les paramètres du constructeur. Cela garantit que l'objet sera toujours créé dans un état valide et que les dépendances ne peuvent pas être modifiées après la création (immuabilité).

public interface MessageService {
    void sendMessage(String message, String recipient);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message, String recipient) {
        System.out.println("Email sent to " + recipient + ": " + message);
    }
}

public class NotificationSender {
    private final MessageService messageService;

    // Injection de dépendance via le constructeur
    public NotificationSender(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String userEmail, String msg) {
        messageService.sendMessage(msg, userEmail);
    }
}

// Utilisation
public class Main {
    public static void main(String[] args) {
        MessageService emailService = new EmailService();
        NotificationSender sender = new NotificationSender(emailService); // DI
        sender.notifyUser("user@example.com", "Hello!");
    }
}

2. Injection par setters (Setter Injection)

Convient pour les dépendances optionnelles ou lorsque la dépendance peut être modifiée pendant la durée de vie de l'objet. Cependant, l'objet peut être créé dans un état incomplet si l'on oublie d'appeler le setter.

public class NotificationSender {
    private MessageService messageService;

    // Setter pour l'injection de dépendance
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String userEmail, String msg) {
        if (messageService != null) {
            messageService.sendMessage(msg, userEmail);
        } else {
            System.o