Inversion of Control (IoC)

L'Inversion of Control (IoC) est un principe qui consiste à déléguer la création, la configuration et l'assemblage des objets et de leurs dépendances à un composant externe, comme un framework.

Spring réalise l'IoC via l'injection de dépendance (DI).

Fonctionnement classique

Sans IoC, une classe crée directement les objets dont elle dépend:

public class UserService {

   private final UserRepository userRepository;

   public UserService() {
      this.userRepository = new UserRepository

Le contrôle appartient à notre code, c'est lui qui décide:

• Quel objet créer
• Quand le créer
• Quelle implémentation utiliser
• Comment assembler les différents objets

UserServiceest donc directement responsable de la création de sa dépendance UserRepository.

Fonctionnement avec l'IoC

Avec l'IoC, les classes déclarent simplement les dépendances dont elles ont besoin:

public class UserService { 
   private final UserRepository userRepository; 

   public UserService(UserRepository userRepository) { 
      this.userRepository = userRepository;

La classe UserService ne crée pas elle-même son UserRepository, c'est un composant extérieur qui se charge de créer les objets et de les assembler.

Dans Spring, cette responsabilité appartient principalement au Conteneur IoC, représenté notamment par l'ApplicationContext.

On parle donc d'inversion de contrôle car le contrôle de la création et de l'assemblage des objets n'appartient plus directement à notre code: il est transféré au framework.

Nos classes ne décident plus comment créer ou obtenir leurs dépendances. Elles indiquent simplement les dépendances dont elles ont besoin.

Avantages

L'IoC et la DI permettent:

• Moins de couplage: Une classe dépend moins directement d'une implémentation précise.
• Plus de modularité: Les composants peuvent être remplacés plus facilement.
• Une meilleure testabilité: On peut injecter des mockes ou des implémentations de test.
• Une meilleure séparation des responsabilités: Une classe se concentre sur sa logique métier au lieu de gérer la création de ses dépendances.

IoC et DI

L'IoC est le principe général: Transférer le contrôle de certaines responsabilités de notre code à un composant extérieur.

La DI est une manière d'appliquer ce principe: Les dépendances d'un objet lui sont fournies depuis l'extérieur au lieu d'être créées par l'objet lui-même.

Dans Spring: Spring IoC Container -> créer et gère les objets -> injecte leurs dépendances.

Sources

• Spring Docs - https://docs.spring.io/spring-framework/reference/core/beans/introduction.html
• JMDoudoux - https://www.jmdoudoux.fr/java/dej/chap-spring_core.htm
• Gayerie - https://gayerie.dev/docs/spring/spring/principe_ioc.html