Spring MVC Course Document

Cours Spring MVC

Ce cours sur Spring MVC couvre la définition du framework, son utilisation avec Postman, le cycle de vie d'une requête HTTP, ainsi que des exemples pratiques de RestController. Les étudiants apprendront également à configurer Spring Boot pour développer des applications web RESTful.

Définition de Spring MVC

Spring MVC est un Framework Web basé sur le design pattern MVC (Model / View / Controller). Il fait partie du projet "Spring Framework" et s'intègre avec diverses technologies de vue telles que JSF, JSP, Velocity, et Thymeleaf. Bien que Spring MVC ne fournisse pas de technologie de vue, il permet de communiquer avec des technologies web performantes comme Angular et React. Ce framework est construit sur la spécification JavaEE : Java Servlet.

Utilisation de Postman avec Spring MVC

Introduction à Postman

Postman est une solution populaire pour interroger et tester les web services et les API. Il offre une interface graphique agréable et permet de construire et d’exécuter des requêtes HTTP, tout en stockant un historique pour les rejouer facilement.

Dépendance web

Pour utiliser Spring MVC, il est nécessaire d'ajouter une dépendance web dans le projet. Le starter web permet d’ajouter toutes les dépendances liées à la partie web, notamment celles liées à Spring MVC et à l’exposition des web services.

Cycle de vie d'une requête HTTP

Le cycle de vie d'une requête HTTP dans une application Spring Boot commence par la réception de la requête par le serveur. Par exemple, pour configurer l'URL de l'application, il faut ajouter les lignes suivantes dans le fichier de propriétés :

#Server configuration
server.port=8089
server.servlet.context-path=/SpringMVC

Exemple de RestController

Voici un exemple de RestController qui expose des méthodes pour gérer des clients :

@RestController
@RequestMapping("/client")
public class ClientRestController {

    @Autowired
    IClientService clientService;

    @GetMapping("/retrieve-all-clients")
    @ResponseBody
    public List<Client> getClients() {
        List<Client> listClients = clientService.retrieveAllClients();
        return listClients;
    }

    @GetMapping("/retrieve-client/{client-id}")
    @ResponseBody
    public Client retrieveClient(@PathVariable("client-id") Long clientId) {
        return clientService.retrieveClient(clientId);
    }

    @PostMapping("/add-client")
    @ResponseBody
    public Client addClient(@RequestBody Client c) {
        Client client = clientService.addClient(c);
        return client;
    }

    @DeleteMapping("/remove-client/{client-id}")
    @ResponseBody
    public void removeClient(@PathVariable("client-id") Long clientId) {
        clientService.deleteClient(clientId);
    }

    @PutMapping("/modify-client")
    @ResponseBody
    public Client modifyClient(@RequestBody Client client) {
        return clientService.updateClient(client);
    }
}

TP - Spring Boot et Spring Data JPA

Dans ce TP, nous allons exposer des Web Services REST en utilisant Spring Boot, Spring Data JPA et Spring MVC. Vous devez avoir créé un projet avec un CRUD sur l’entité Client, qui a été testé avec JUnit. Nous allons reprendre ce projet et exposer ces méthodes (CRUD) via des Web Services REST, qui seront testés avec Postman.

Configuration de Spring Boot

Assurez-vous que le fichier de propriétés contient les propriétés nécessaires pour la configuration de votre application :

#Server configuration
server.servlet.context-path=/SpringMVC
server.port=8089

### DATABASE ###
spring.datasource.url=jdbc:mysql://localhost:3306/springDB?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=

### JPA / HIBERNATE ###
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

Création des packages et des classes

Créez le package tn.esprit.spring.control et le bean Spring ClientRestController annoté avec @RestController. Ensuite, créez les méthodes nécessaires pour exposer le CRUD.

Tester les méthodes avec Postman

Une fois les méthodes exposées, utilisez Postman pour tester l’ensemble des méthodes créées. Cela vous permettra de vérifier que les Web Services fonctionnent correctement.

Points clés à retenir

• Spring MVC est basé sur le design pattern MVC.
• Postman est un outil efficace pour tester les API.
• La configuration de Spring Boot est essentielle pour le bon fonctionnement de l'application.
• Les RestControllers permettent d'exposer des méthodes CRUD.

Glossaire des termes clés

• Spring MVC : Framework Web basé sur le design pattern MVC.
• Postman : Outil pour tester les API et les web services.
• RestController : Classe qui gère les requêtes HTTP dans une application Spring.
• CRUD : Opérations de base pour gérer les données (Créer, Lire, Mettre à jour, Supprimer).

Questions fréquentes

Qu'est-ce que Spring MVC ?

Spring MVC est un framework qui permet de développer des applications web en suivant le design pattern MVC. Il facilite la séparation des préoccupations entre la logique métier, la présentation et le contrôle des flux d'application.

Comment utiliser Postman avec Spring MVC ?

Postman peut être utilisé pour tester les API développées avec Spring MVC. Il permet de créer des requêtes HTTP, d'envoyer des données et de visualiser les réponses des services web.

Quel est le cycle de vie d'une requête HTTP dans Spring ?

Le cycle de vie d'une requête HTTP dans Spring commence par la réception de la requête par le serveur, suivie par le traitement par le contrôleur, et se termine par l'envoi de la réponse au client.

Comment configurer Spring Boot pour une application web ?

La configuration de Spring Boot se fait principalement via un fichier de propriétés où vous définissez des paramètres comme le port du serveur et le chemin du contexte de l'application.

Quels sont les principaux composants d'un RestController ?

Un RestController contient des méthodes annotées pour gérer les requêtes HTTP, comme @GetMapping, @PostMapping, @PutMapping et @DeleteMapping, qui correspondent aux opérations CRUD.