Java — Injection de dépendances (Dependency Injection)

L’injection de dépendances (DI) est un concept clé en architecture logicielle moderne. Elle permet de rendre le code plus flexible, testable et maintenable.

1. Idée simple

Au lieu de créer ses dépendances (new), une classe les reçoit de l’extérieur

➡️ on injecte les dépendances

2. Problème sans DI

class UserService {
    private UserRepository repo = new UserRepository();
}

Problèmes :

couplage fort
difficile à tester
impossible de remplacer facilement

3. Solution avec DI

class UserService {
    private UserRepository repo;

    public UserService(UserRepository repo) {
        this.repo = repo;
    }
}

Ici :

la dépendance est fournie de l’extérieur
plus flexible

4. Types d’injection

Injection par constructeur (recommandé)

public UserService(UserRepository repo) {
    this.repo = repo;
}

immuable et clair

Injection par setter

public void setRepo(UserRepository repo) {
    this.repo = repo;
}

flexible mais moins sûr

Injection par champ (frameworks)

@Autowired
private UserRepository repo;

utilisé avec frameworks (ex: Spring)

5. Avantages

réduit le couplage
facilite les tests (mock facilement)
améliore la maintenabilité
rend le code modulaire

6. Pièges fréquents

confondre DI et Factory
trop dépendre des frameworks
injection par champ difficile à tester

7. DI vs Factory

	DI	Factory
rôle	fournir dépendances	créer objets
responsabilité	externe	interne

souvent utilisés ensemble

8. Questions classiques

Q1

Pourquoi utiliser DI ? réduire le couplage

Q2

meilleure méthode ? constructeur

Q3

DI remplace new ? souvent oui

9. À retenir

DI = dépendances injectées
évite le new direct
améliore testabilité
essentiel en architecture moderne

🧾 En résumé

une classe ne crée pas ses dépendances
elle les reçoit
cela rend le code plus flexible et maintenable

La DI est un pilier du développement moderne (notamment avec Spring).