Annotations de Composants Spring: @Component, @Service, @RestController

1. L'Architecture en Couches : Organiser le Code

Avant de plonger dans les annotations, demandons-nous : pourquoi en avons-nous besoin ? Dans une application professionnelle, on ne met pas tout le code dans un seul fichier. On l'organise en couches, chacune avec une responsabilité claire. Une architecture typique en 3 couches (ou 3-tier) est :

1. Couche de Présentation (Presentation Layer) : Responsable de la gestion des requêtes HTTP entrantes et des réponses sortantes. Pour une API REST, c'est elle qui expose les endpoints.
2. Couche de Service (Service/Business Layer) : Contient la logique métier de l'application. C'est le "cerveau" de l'application, qui orchestre les opérations.
3. Couche d'Accès aux Données (Data Access Layer) : Gère la communication avec la base de données (créer, lire, mettre à jour, supprimer des données).

La vidéo suivante explique très bien ce concept fondamental.

Spring utilise des annotations spécifiques, appelées stéréotypes, pour identifier à quelle couche appartient une classe.

2. Les Annotations de Définition de Composants

Pour que Spring puisse gérer un objet (créer une instance, l'injecter ailleurs), il doit d'abord savoir que cet objet est un "composant Spring" (un bean). On le lui indique en annotant nos classes. Spring effectue alors un balayage des composants (component scanning) au démarrage pour trouver ces classes et les enregistrer dans son conteneur IoC.

L'article ci-dessous présente les trois annotations au cœur de cette leçon.

Pour compléter cette lecture, la vidéo suivante vous montrera concrètement à quoi ressemblent ces annotations dans le code.

Synthèse des annotations

En résumé :

• Utilisez @RestController pour les classes qui répondent aux requêtes HTTP de votre API.
• Utilisez @Service pour les classes qui implémentent la logique de votre application.
• Utilisez @Component pour tout autre bean qui ne rentre pas dans les catégories ci-dessus (par exemple, des classes utilitaires).

3. Mise en Pratique : Votre Premier Endpoint

Assez de théorie, passons au code ! Nous allons créer un endpoint simple qui retourne "Hello World". Un endpoint est simplement une URL que les clients (comme un navigateur ou une application frontend) peuvent appeler pour interagir avec votre API.

1. Créez un package controller : Dans src/main/java, à l'intérieur de votre package de base (ex: com.votreentreprise.monapirest), faites un clic droit > New > Package. Nommez-le controller. C'est une bonne pratique pour organiser vos contrôleurs.

2. Créez la classe HelloController : Dans ce nouveau package controller, créez une classe Java nommée HelloController.

3. Annotez la classe et la méthode : Modifiez votre classe pour qu'elle ressemble à ceci :

   package com.votreentreprise.monapirest.controller;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class HelloController {
   
       @GetMapping("/hello")
       public String sayHello() {
           return "Hello World!";
       }
   }
   

   Analyse du code :

   • @RestController : Déclare cette classe comme un contrôleur REST. Spring sait maintenant qu'elle peut gérer des requêtes web.
   • @GetMapping("/hello") : Mappe les requêtes HTTP GET vers l'URL /hello à la méthode sayHello().
   • La méthode retourne une String. Grâce à @RestController, Spring va automatiquement la transformer en une réponse HTTP avec le corps de texte "Hello World!".

4. Lancez et testez : Lancez votre application comme vous l'avez fait dans la leçon précédente. Une fois démarrée, ouvrez votre navigateur et allez à l'adresse http://localhost:8080/hello.

Vous devriez voir "Hello World!" s'afficher. Félicitations, votre API vient de répondre à sa première requête !

4. Lier les Composants : Service et Contrôleur

Créons maintenant un Service et injectons-le dans notre Controller pour voir comment les couches communiquent.

1. Créez un package service : Similaire à l'étape précédente, créez un nouveau package service.

2. Créez la classe MessageService : Dans le package service, créez cette classe :

   package com.votreentreprise.monapirest.service;
   
   import org.springframework.stereotype.Service;
   
   @Service
   public class MessageService {
   
       public String getGreetingMessage() {
           return "Message depuis le service !";
       }
   }
   

   • @Service : Déclare cette classe comme un composant de la couche service. Spring va en créer une instance.

3. Injectez le service dans le contrôleur : Modifiez votre HelloController pour utiliser ce service.

   package com.votreentreprise.monapirest.controller;
   
   import com.votreentreprise.monapirest.service.MessageService;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class HelloController {
   
       private final MessageService messageService;
   
       // Injection de dépendance par le constructeur
       public HelloController(MessageService messageService) {
           this.messageService = messageService;
       }
   
       @GetMapping("/hello")
       public String sayHello() {
           return "Hello World!";
       }
   
       @GetMapping("/greeting")
       public String getGreeting() {
           return messageService.getGreetingMessage();
       }
   }
   

   Analyse des modifications :

   • Nous avons ajouté un champ private final MessageService messageService.
   • Nous avons créé un constructeur qui prend MessageService en paramètre. C'est ici que la magie de l'Injection de Dépendances opère : Spring voit que le constructeur de HelloController a besoin d'un MessageService. Il regarde dans son conteneur, trouve le bean MessageService qu'il a créé (grâce à @Service), et le passe automatiquement au constructeur.
   • Nous avons ajouté un nouvel endpoint /greeting qui appelle la méthode de notre service.

4. Relancez et testez : Redémarrez votre application. Testez l'ancien endpoint http://localhost:8080/hello, puis le nouveau : http://localhost:8080/greeting.

Vous avez maintenant un flux complet : la requête HTTP arrive au @RestController, qui délègue le travail au @Service, puis retourne le résultat.

Conclusion

Aujourd'hui, vous avez posé les briques fondamentales de toute application Spring. Vous avez non seulement appris la théorie derrière les composants et les stéréotypes, mais vous l'avez mise en pratique en créant une mini-API fonctionnelle.

Voici les points essentiels à retenir :

• Les applications Spring sont organisées en couches (Présentation, Service, Données) pour une meilleure structure.
• Spring découvre les classes à gérer via un balayage de composants en cherchant des annotations de stéréotypes.
• @Component est l'annotation de base.
• @RestController est utilisée pour la couche de présentation d'une API REST, gérant les requêtes et réponses HTTP.
• @Service est utilisée pour la couche métier, où réside la logique principale de l'application.
• L'injection par constructeur est la manière privilégiée pour qu'un composant en utilise un autre.

Vous avez maintenant tous les outils pour commencer à construire la logique de votre application.

Dans la prochaine leçon, nous allons approfondir le mécanisme d'injection de dépendances. Nous explorerons plus en détail l'annotation @Autowired, ses différentes modalités d'utilisation (constructeur, champ, setter) et nous consoliderons pourquoi l'injection par constructeur est considérée comme une bonne pratique professionnelle.