Les contrôleurs sont un concept clé de Spring MVC. Ils agissent comme des intermédiaires entre les requêtes entrantes et les modèles de données, en traitant les demandes et en renvoyant des réponses appropriées.

Spring utilise le modèle Front Controller pour implémenter MVC. 

Le DispatcherServlet de Spring agit comme le contrôleur principal pour acheminer les demandes vers leur destination prévue.

Le modèle représente les données de notre application, tandis que la vue est représentée par l’un des différents moteurs de template.

Pour créer un contrôleur dans Spring, vous pouvez utiliser l’annotation @Controller ou @RestController pour annoter une classe. L’annotation @Controller est utilisée pour les contrôleurs MVC traditionnels qui renvoient des vues, tandis que l’annotation @RestController est utilisée pour les contrôleurs RESTful qui renvoient des données brutes (généralement JSON ou XML).

Les méthodes de gestionnaire dans un contrôleur peuvent être annotées avec des annotations telles que @RequestMapping, @GetMapping, @PostMapping, etc. pour mapper les demandes entrantes à des méthodes spécifiques.

Ces méthodes peuvent prendre en paramètre des objets tels que HttpServletRequest, HttpServletResponse, Model, etc. pour interagir avec la demande et la réponse.

Les contrôleurs peuvent également utiliser des annotations telles que @RequestParam, @PathVariable, @RequestBody, etc. pour lier les paramètres de méthode aux parties de la demande, telles que les paramètres de requête, les variables de chemin et le corps de la requête.

 

Pour créer un contrôleur dans Spring, vous pouvez utiliser l’annotation @Controller ou @RestController pour annoter une classe. L’annotation @Controller est utilisée pour les contrôleurs MVC traditionnels qui renvoient des vues, tandis que l’annotation @RestController est utilisée pour les contrôleurs RESTful qui renvoient des données brutes (généralement JSON ou XML).

Voici un exemple simple de contrôleur RESTful qui renvoie une liste de chaînes:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

@RestController
public class MyController {

    @GetMapping("/strings")
    public List<String> getStrings() {
        return Arrays.asList("one", "two", "three");
    }
}

Dans cet exemple, nous avons créé une classe MyController annotée avec @RestController. Nous avons également défini une méthode getStrings annotée avec @GetMapping pour mapper les demandes GET à l’URI /strings à cette méthode. La méthode renvoie une liste de chaînes.

@Controller et @RestController

@Controller et @RestController sont deux annotations utilisées dans Spring pour définir des contrôleurs. La principale différence entre ces deux annotations est que @Controller est utilisé pour créer des contrôleurs qui renvoient des vues, tandis que @RestController est utilisé pour créer des contrôleurs qui renvoient des données sous forme de réponse HTTP.

@Controller est l’annotation originale utilisée pour définir des contrôleurs dans Spring. Elle indique que la classe annotée est un contrôleur et peut gérer les requêtes HTTP. Lorsque vous utilisez cette annotation, vous devez utiliser l’annotation @ResponseBody sur les méthodes du contrôleur pour indiquer que la valeur de retour de la méthode doit être écrite directement dans le corps de la réponse HTTP.

@RestController est une annotation plus récente qui combine les fonctionnalités de @Controller et @ResponseBody. Elle indique que la classe annotée est un contrôleur et que toutes les méthodes du contrôleur renvoient des données qui doivent être écrites directement dans le corps de la réponse HTTP. Cela signifie que vous n’avez pas besoin d’utiliser l’annotation @ResponseBody sur les méthodes du contrôleur lorsque vous utilisez @RestController.

En résumé, si vous créez un contrôleur qui renvoie des vues, vous devez utiliser l’annotation @Controller. Si vous créez un contrôleur qui renvoie des données sous forme de réponse HTTP, vous pouvez utiliser l’annotation @RestController.

 

@GetMapping, @PostMapping, @PutMapping et @DeleteMapping

Les annotations @GetMapping, @PostMapping, @PutMapping et @DeleteMapping sont des annotations spécifiques à Spring qui sont utilisées pour mapper les requêtes HTTP entrantes vers des méthodes de contrôleur spécifiques dans une application Spring MVC. Ces annotations sont des raccourcis pour l’annotation @RequestMapping, qui peut être utilisée pour mapper toutes les requêtes HTTP entrantes vers des méthodes de contrôleur.

Voici une brève description de chaque annotation:

  • @GetMapping: Cette annotation est utilisée pour mapper les requêtes HTTP GET vers une méthode de contrôleur spécifique. Par exemple, si vous avez une méthode qui renvoie une liste d’utilisateurs, vous pouvez utiliser l’annotation @GetMapping pour indiquer que cette méthode doit être appelée lorsque l’application reçoit une requête HTTP GET pour l’URL spécifiée.

  • @PostMapping: Cette annotation est utilisée pour mapper les requêtes HTTP POST vers une méthode de contrôleur spécifique. Par exemple, si vous avez une méthode qui crée un nouvel utilisateur, vous pouvez utiliser l’annotation @PostMapping pour indiquer que cette méthode doit être appelée lorsque l’application reçoit une requête HTTP POST pour l’URL spécifiée.

  • @PutMapping: Cette annotation est utilisée pour mapper les requêtes HTTP PUT vers une méthode de contrôleur spécifique. Par exemple, si vous avez une méthode qui met à jour les informations d’un utilisateur existant, vous pouvez utiliser l’annotation @PutMapping pour indiquer que cette méthode doit être appelée lorsque l’application reçoit une requête HTTP PUT pour l’URL spécifiée.

  • @DeleteMapping: Cette annotation est utilisée pour mapper les requêtes HTTP DELETE vers une méthode de contrôleur spécifique. Par exemple, si vous avez une méthode qui supprime un utilisateur existant, vous pouvez utiliser l’annotation @DeleteMapping pour indiquer que cette méthode doit être appelée lorsque l’application reçoit une requête HTTP DELETE pour l’URL spécifiée.

@RequestParam, @PathVariable, et @RequestBody

@RequestParam, @PathVariable, et @RequestBody sont des annotations utilisées dans Spring pour lier les paramètres de méthode de contrôleur aux données de requête HTTP. La principale différence entre ces annotations est la source des données qu’elles lient.

 

  • @RequestParam est utilisé pour lier les paramètres de méthode aux paramètres de requête HTTP. Par exemple, si vous avez une URL qui contient un paramètre de requête id, vous pouvez utiliser l’annotation @RequestParam pour lier la valeur de ce paramètre à un paramètre de méthode dans votre contrôleur.

  • @PathVariable est utilisé pour lier les paramètres de méthode aux variables de chemin d’URL. Par exemple, si vous avez une URL qui contient une variable de chemin id, vous pouvez utiliser l’annotation @PathVariable pour lier la valeur de cette variable à un paramètre de méthode dans votre contrôleur.

  • @RequestBody est utilisé pour lier les paramètres de méthode au corps de la requête HTTP. Cette annotation est généralement utilisée pour lier les données envoyées dans le corps d’une requête POST ou PUT à un paramètre de méthode dans votre contrôleur.

 

En résumé, ces trois annotations vous permettent de lier les données de requête HTTP à des paramètres de méthode dans vos contrôleurs Spring, mais elles diffèrent par la source des données qu’elles lient.

Exemple:

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

Dans cet exemple, nous avons un contrôleur UserController qui utilise les annotations @GetMapping, @PostMapping, @PutMapping et @DeleteMapping pour mapper les requêtes HTTP entrantes vers des méthodes de contrôleur spécifiques. La méthode getAllUsers est mappée à l’URL /users avec l’annotation @GetMapping, ce qui signifie qu’elle sera appelée lorsque l’application reçoit une requête HTTP GET pour cette URL. De même, la méthode createUser est mappée à la même URL avec l’annotation @PostMapping, ce qui signifie qu’elle sera appelée lorsque l’application reçoit une requête HTTP POST pour cette URL.

 

Résumé

En résumé, les contrôleurs sont un élément clé de Spring MVC qui permettent de gérer les demandes entrantes et de renvoyer des réponses appropriées. Ils peuvent être créés en utilisant des annotations telles que @Controller ou @RestController et peuvent utiliser d’autres annotations pour mapper les demandes à des méthodes spécifiques et lier les paramètres de méthode aux parties de la demande.

@RequestParam, @PathVariable, et @RequestBody sont des annotations utilisées dans Spring pour lier les paramètres de méthode de contrôleur aux données de requête HTTP.

Les annotations @GetMapping, @PostMapping, @PutMapping et @DeleteMapping sont des annotations spécifiques à Spring qui sont utilisées pour mapper les requêtes HTTP entrantes vers des méthodes de contrôleur spécifiques dans une application Spring MVC. En attribut il est possible d'indiquer les routes qui définiront les url.

 

Modifié le: jeudi 7 septembre 2023, 03:36