MVC avec Spring

MVC Projet Structure

MVC est avant tout une façon de structurer une application.

mon-projet/
├── pom.xml
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/
    │   │       └── monentreprise/
    │   │           └── monprojet/
    │   │               ├── controleur/
    │   │               ├── repository/
    │   │               ├── modele/
    │   │               └── vue/
    │   ├── resources/
    │   └── webapp/
    │       ├── WEB-INF/
    │       └── resources/
    └── test/
        ├── java/
        └── resources/

Dans cette structure, le répertoire src/main/java contient le code source de l’application, organisé en packages pour les contrôleurs, les modèles et les vues. Le répertoire src/main/resources contient les fichiers de ressources, tels que les fichiers de configuration de Spring. Le répertoire src/main/webapp contient les fichiers liés à la partie web de l’application, tels que les fichiers JSP et les ressources statiques (images, CSS, JavaScript, etc.).

Le répertoire src/test contient les fichiers liés aux tests de l’application, avec une structure similaire à celle du répertoire src/main.

• Java Guides

Spring MVC

Spring MVC est un framework Java populaire pour la création d’applications Web. Il suit le modèle de conception Model-View-Controller (MVC), qui divise une application en trois parties interconnectées: le modèle, la vue et le contrôleur.

Le modèle représente les données de l’application et les règles métier qui régissent l’accès à ces données. La vue est responsable de la présentation des données à l’utilisateur, généralement sous forme de pages HTML. Le contrôleur gère les interactions entre la vue et le modèle, en traitant les demandes entrantes, en mettant à jour le modèle et en renvoyant des réponses appropriées.

Spring MVC utilise un modèle de programmation basé sur les annotations pour définir les contrôleurs et les méthodes de gestionnaire. Les contrôleurs peuvent être annotés avec @Controller ou @RestController, tandis que les méthodes de gestionnaire peuvent être annotées avec des annotations telles que @RequestMapping, @GetMapping, @PostMapping, etc. pour mapper les demandes entrantes à des méthodes spécifiques.

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.

Spring MVC fournit également un support pour la validation des données, la conversion des types, la gestion des exceptions, la négociation du contenu et d’autres fonctionnalités utiles pour la création d’applications Web robustes.

Voici un exemple simple de contrôleur Spring MVC qui gère les demandes liées aux utilisateurs:

@Controller
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public String listUsers(Model model) {
        List<User> users = userService.findAll();
        model.addAttribute("users", users);
        return "users/list";
    }

    @GetMapping("/{id}")
    public String showUser(@PathVariable Long id, Model model) {
        User user = userService.findById(id);
        model.addAttribute("user", user);
        return "users/show";
    }

    @GetMapping("/new")
    public String newUser(Model model) {
        model.addAttribute("user", new User());
        return "users/new";
    }

    @PostMapping
    public String createUser(@Valid User user, BindingResult result) {
        if (result.hasErrors()) {
            return "users/new";
        }
        userService.save(user);
        return "redirect:/users";
    }
}

Dans cet exemple, nous avons créé une classe UserController annotée avec @Controller et @RequestMapping pour indiquer qu’il s’agit d’un contrôleur et pour mapper les demandes à l’URI /users. Le contrôleur utilise l’annotation @Autowired pour injecter une instance de UserService dans la classe, qui est utilisée pour effectuer des opérations CRUD (Create, Read, Update, Delete) sur les données des utilisateurs.

Le contrôleur définit plusieurs méthodes de gestionnaire pour gérer les différentes demandes liées aux utilisateurs:

• listUsers(Model model): Cette méthode est annotée avec @GetMapping pour mapper les demandes GET à l’URI /users à cette méthode. La méthode renvoie une vue nommée users/list qui affiche une liste de tous les utilisateurs.
• showUser(@PathVariable Long id, Model model): Cette méthode est annotée avec @GetMapping("/{id}") pour mapper les demandes GET à l’URI /users/{id} à cette méthode. La méthode prend en paramètre un identifiant d’utilisateur et renvoie une vue nommée users/show qui affiche les détails de l’utilisateur correspondant.
• newUser(Model model): Cette méthode est annotée avec @GetMapping("/new") pour mapper les demandes GET à l’URI /users/new à cette méthode. La méthode renvoie une vue nommée users/new qui affiche un formulaire pour créer un nouvel utilisateur.
• createUser(@Valid User user, BindingResult result): Cette méthode est annotée avec @PostMapping pour mapper les demandes POST à l’URI /users à cette méthode. La méthode prend en paramètre un objet User validé et crée un nouvel utilisateur dans la base de données. Si des erreurs de validation sont détectées, la méthode renvoie la vue users/new. Sinon, elle redirige vers l’URI /users.