Le conteneur Spring est le composant central du Spring Framework qui gère la création, la configuration et le cycle de vie des beans (objets) au sein d'une application. Le conteneur Spring est également appelé le conteneur IoC.

Une dépendance désigne toute classe nécessitant que d'autres objets soient injectés pour fonctionner correctement, et cette chaîne de dépendances peut se poursuivre indéfiniment. Habituellement, pour créer un objet avec des dépendances, il faut l'initialiser explicitement à l'aide de l'opérateur new et spécifier la classe.

C'est là que Spring intervient avec l'Inversion of Control et l'Dependency Injection. Le principe est que Spring prend en charge la responsabilité de créer et de gérer les dépendances. Au lieu de gérer manuellement la configuration, il suffit d'annoter les classes nécessaires, et Spring les crée automatiquement et gère leur cycle de vie dans son contexte.

L'une de ces annotations est @Component, que l'on place au-dessus de la classe.

BeanExample.java


              123
            
@Component
public class BeanExample {
}

Cette approche déplace l'attention de la gestion manuelle des dépendances, permettant aux développeurs de se concentrer sur la logique métier tandis que Spring prend en charge les tâches d'infrastructure liées à la création d'objets et à la gestion des dépendances.

Comment fonctionne le conteneur Spring ?

Lorsque l'application démarre, le conteneur Spring est initialisé. Il commence par analyser les classes à la recherche d'annotations telles que @Component, @Service, @Repository et @Configuration.

@Component est une annotation générale qui rend une classe gérée par Spring, permettant ainsi son enregistrement en tant que bean.

@Service, @Repository et @Controller sont des versions plus spécialisées de @Component. Elles remplissent la même fonction mais indiquent le rôle spécifique de la classe : @Service pour la logique métier, @Repository pour l'accès aux données et @Controller pour la gestion des requêtes web.

@Configuration est utilisée pour les classes qui contiennent des définitions de beans et la configuration de l'application.

En marquant une classe avec l'une de ces annotations, cela garantit qu'elle devient un bean dans le contexte Spring.

Une fois que les classes sont identifiées, le conteneur procède à la création d'instances de ces classes annotées, les transformant ainsi en beans que le contexte Spring gère tout au long du cycle de vie de l'application.

Au fur et à mesure que ces beans sont créés, le conteneur gère automatiquement leurs dépendances via l'injection de dépendances. Ce processus permet aux classes de recevoir les dépendances nécessaires sans avoir à les créer ou à les localiser explicitement, simplifiant ainsi le processus de développement.

Injection de dépendances (DI)

Tout d'abord, le conteneur Spring ajoute à son contexte les beans (classes) marqués avec les annotations @Component, @Service, @Repository et @Configuration. Ensuite, il fournit ces beans à tout objet qui en fait la demande.

Exemple concret

Imaginez que vous développez une boutique en ligne. Vous disposez d'une classe OrderService qui gère les commandes et d'une classe PaymentService qui gère les paiements. Au lieu de créer manuellement une instance de PaymentService à l'intérieur de OrderService, vous pouvez laisser le conteneur Spring créer et injecter PaymentService dans OrderService.

OrderService.java

PaymentService.java


              1234567891011121314
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Dans la classe OrderService, un champ paymentService est initialisé avec le type exact requis (PaymentService). Remarquez que cet objet n'a pas été explicitement initialisé ; Spring l'a fait automatiquement !

Si PaymentService n'était pas annoté avec @Service, ce bean n'aurait pas été ajouté au contexte Spring, ce qui aurait entraîné une erreur indiquant que Spring ne trouve pas ce bean.

@Autowired

L'annotation @Autowired peut également être utilisée pour indiquer au conteneur Spring d'injecter l'objet approprié dans le champ.

OrderService.java


              123456789101112131415
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Dans Spring, à partir de la version 4.3, l'utilisation de l'annotation @Autowired n'est plus requise lors de l'injection de dépendances via un constructeur s'il n'y a qu'un seul constructeur dans la classe. Spring détermine automatiquement que ce constructeur doit être utilisé pour l'injection de dépendances.

Quels sont les différents types de Bean ?

Imaginez que vous disposez d'une seule machine à café dans un café. Chaque fois qu'un client commande un café, le barista utilise cette même machine à café pour préparer chaque tasse. La machine à café est toujours la même, il ne s'agit pas d'une nouvelle pour chaque commande.

De la même manière, dans Spring, lorsque vous injectez un bean depuis le contexte Spring, Spring vous fournit à chaque fois la même instance de ce bean. Cela correspond au scope singleton. Comme la machine à café du café, Spring garantit que vous obtenez toujours le même objet au lieu d'en créer un nouveau à chaque fois.

Singleton

Il est possible de définir le type à l'aide de l'annotation @Scope et de spécifier singleton dans les attributs.

SingletonService.


              12345
            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java


              12345
            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

Nous faisons la même chose, mais nous spécifions prototype dans les attributs. Cela garantit que chaque fois que nous injectons ce bean, un nouvel objet sera retourné.

Résumé

Dans ce chapitre sur l’IoC (Inversion de Contrôle) et l’ID (Injection de Dépendances), nous avons examiné comment Spring gère la création et le cycle de vie des beans via son conteneur, permettant l’injection automatique des dépendances.

Nous avons abordé la portée par défaut singleton, où une seule instance d’un bean est réutilisée, et la portée prototype, qui crée une nouvelle instance pour chaque requête, en soulignant comment ces portées influencent la gestion des objets et la conception de l’application.

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 3.45

Glissez pour afficher le menu

L'une de ces annotations est @Component, que l'on place au-dessus de la classe.

BeanExample.java


              123
            
@Component
public class BeanExample {
}

Comment fonctionne le conteneur Spring ?

@Component est une annotation générale qui rend une classe gérée par Spring, permettant ainsi son enregistrement en tant que bean.

@Configuration est utilisée pour les classes qui contiennent des définitions de beans et la configuration de l'application.

En marquant une classe avec l'une de ces annotations, cela garantit qu'elle devient un bean dans le contexte Spring.

Injection de dépendances (DI)

Exemple concret

OrderService.java

PaymentService.java


              1234567891011121314
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

@Autowired

L'annotation @Autowired peut également être utilisée pour indiquer au conteneur Spring d'injecter l'objet approprié dans le champ.

OrderService.java


              123456789101112131415
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Quels sont les différents types de Bean ?

Singleton

Il est possible de définir le type à l'aide de l'annotation @Scope et de spécifier singleton dans les attributs.

SingletonService.


              12345
            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java


              12345
            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

Nous faisons la même chose, mais nous spécifions prototype dans les attributs. Cela garantit que chaque fois que nous injectons ce bean, un nouvel objet sera retourné.

Résumé

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4

IoC et DI

Comment fonctionne le conteneur Spring ?

Injection de dépendances (DI)

Exemple concret

@Autowired

Quels sont les différents types de Bean ?

Singleton

Prototype

Résumé

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?

Awesome!

IoC et DI

Comment fonctionne le conteneur Spring ?

Injection de dépendances (DI)

Exemple concret

@Autowired

Quels sont les différents types de Bean ?

Singleton

Prototype

Résumé

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?

IoC et DI

Comment fonctionne le conteneur Spring ?

Injection de dépendances (DI)

Exemple concret

@Autowired

Quels sont les différents types de Bean ?

Singleton

Prototype

Résumé

1. Qu’est-ce que l’Inversion of Control (IoC) dans Spring ?

2. Quel principe sous-tend l’Dependency Injection (ID) ?

Awesome!

IoC et DI

Comment fonctionne le conteneur Spring ?

Injection de dépendances (DI)

Exemple concret

@Autowired

Quels sont les différents types de Bean ?

Singleton

Prototype

Résumé

1. Qu’est-ce que l’Inversion of Control (IoC) dans Spring ?

2. Quel principe sous-tend l’Dependency Injection (ID) ?

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?

1. Qu’est-ce que l’`Inversion of Control` (IoC) dans Spring ?

2. Quel principe sous-tend l’`Dependency Injection` (ID) ?