Spring MVC

Spring MVC est un module du Spring Framework qui implémente le pattern Model-View-Controller pour créer des applications web en Java. Il offre une architecture flexible et découplée permettant de séparer clairement la logique métier, la présentation et le contrôle des flux applicatifs. Spring MVC s'intègre parfaitement avec l'écosystème Spring pour gérer l'injection de dépendances, la sécurité et l'accès aux données.

Fondements de Spring MVC

• DispatcherServlet : servlet frontal qui intercepte toutes les requêtes HTTP et les route vers les contrôleurs appropriés
• Controllers : composants annotés avec @Controller qui gèrent les requêtes et retournent des vues ou des données
• ViewResolvers : mécanismes configurables pour résoudre les vues (JSP, Thymeleaf, JSON) à partir des noms retournés
• HandlerMappings : système de mapping entre les URLs et les méthodes des contrôleurs via annotations ou configuration

Avantages de Spring MVC

• Séparation des responsabilités : architecture MVC claire facilitant la maintenance et les tests unitaires
• Flexibilité de configuration : support de l'annotation-based, XML et Java config pour s'adapter à tous les contextes
• Intégration écosystème : compatibilité native avec Spring Boot, Spring Security, Spring Data pour des stacks complètes
• Support multi-formats : gestion transparente de JSON, XML, HTML via content negotiation et converters
• Testabilité : MockMvc permet de tester les contrôleurs sans démarrer de serveur applicatif

Exemple concret de contrôleur Spring MVC

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping
    public ResponseEntity<List<Product>> getAllProducts(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        
        Page<Product> products = productService.findAll(
            PageRequest.of(page, size)
        );
        
        return ResponseEntity.ok()
            .header("X-Total-Count", String.valueOf(products.getTotalElements()))
            .body(products.getContent());
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable Long id) {
        return productService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Product createProduct(@Valid @RequestBody ProductDTO productDTO) {
        return productService.create(productDTO);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(
            @PathVariable Long id,
            @Valid @RequestBody ProductDTO productDTO) {
        
        return productService.update(id, productDTO)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteProduct(@PathVariable Long id) {
        productService.delete(id);
    }

    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleProductNotFound(
            ProductNotFoundException ex) {
        
        ErrorResponse error = new ErrorResponse(
            HttpStatus.NOT_FOUND.value(),
            ex.getMessage()
        );
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
    }
}

Mise en œuvre de Spring MVC

1. Configurer Spring Boot avec spring-boot-starter-web pour obtenir Spring MVC automatiquement configuré
2. Créer les contrôleurs avec @RestController ou @Controller selon le type de réponse (JSON/HTML)
3. Définir les routes avec @RequestMapping, @GetMapping, @PostMapping et les paramètres avec @PathVariable, @RequestParam
4. Implémenter la validation avec @Valid et les annotations Bean Validation sur les DTOs
5. Configurer les interceptors et filtres pour la gestion transverse (logging, authentification, CORS)
6. Mettre en place les exception handlers avec @ExceptionHandler ou @ControllerAdvice pour une gestion centralisée
7. Tester avec MockMvc et @WebMvcTest pour valider les routes et la sérialisation sans serveur complet

Outils et extensions Spring MVC

• Spring Boot : configuration automatique et serveur embarqué pour démarrer rapidement
• Spring Security : intégration pour authentification et autorisation avec filtres Spring MVC
• SpringDoc OpenAPI : génération automatique de documentation API basée sur les annotations de contrôleur
• Thymeleaf : moteur de template moderne pour les vues HTML côté serveur
• Jackson : sérialisation/désérialisation JSON configurée par défaut dans Spring MVC
• Hibernate Validator : implémentation de Bean Validation pour valider les requêtes
• Spring HATEOAS : création d'APIs REST hypermedia conformes aux principes REST niveau 3

Spring MVC reste la référence pour construire des applications web d'entreprise en Java grâce à sa maturité, sa flexibilité et son écosystème complet. Son architecture MVC bien définie facilite la collaboration en équipe et la maintenance sur le long terme. Couplé à Spring Boot, il permet de développer rapidement des APIs REST performantes et scalables, répondant aux exigences des architectures microservices modernes tout en offrant la robustesse nécessaire aux systèmes critiques.