Cours Spring MVC en PDF (Intermédiaire)

Spring MVC - installation et utilisation : Ce qu'il faut savoir. Spring MVC est un framework Java pour construire des applications web selon le patron Model‑View‑Controller. Il s'appuie sur le DispatcherServlet pour router les requêtes HTTP vers des contrôleurs et des vues. Ce manuel technique décrit l'installation pratique (Eclipse, Tomcat, jars, build.xml) et les configurations essentielles pour déployer une application MVC opérationnelle. Ce manuel couvre également les concepts de HandlerMapping, ViewResolver et le cycle de vie du DispatcherServlet, utiles pour diagnostiquer les problèmes de routage et de résolution de vues.

🎯 Ce que vous allez apprendre

• Structure de projet et déploiement Tomcat — organisation des répertoires (classes, jsp, WEB-INF) et fichiers de déploiement web.xml : création de l'arborescence d'une application Spring MVC et configuration de Tomcat pour un déploiement reproductible et la résolution d'erreurs liées aux chemins de ressources.
• Configurer le DispatcherServlet et le mapping d'URL — rôle du DispatcherServlet dans le routage des requêtes et configuration des mappings (*.html) dans web.xml et springmvc-servlet.xml : liaison d'URLs à des contrôleurs et compréhension du flux request → DispatcherServlet → contrôleur → vue.
• Déclaration d'un ViewResolver et rendu JSP — fonctionnement du viewResolver pour traduire un nom logique de vue en JSP physique (/jsp/view_name.jsp) : maîtrise de la résolution des vues JSP et de l'exposition des attributs de modèle côté serveur pour affichage côté client.
• Implémentation de contrôleurs et de managers — exemples concrets fournis (HelloWorldController, CarListController, CarManager) montrant l'interaction entre contrôleur, service/manager et modèle (Car, Brand) : codage d'un contrôleur, appel d'un manager de domaine et transmission de modèles aux JSP.
• Gestion des dépendances et build Ant — liste des jars requis (spring.jar, spring-webmvc.jar, standard.jar, commons-logging.jar, servlet-api.jar, jstl.jar) et fichiers de build (build.properties, build.xml) : assembler, packager et déployer l'application avec Ant en maîtrisant les classpaths. Remarque moderne : Maven ou Gradle constituent des alternatives courantes à Ant pour la gestion des dépendances et la standardisation des répertoires de projet.

Les annotations Spring MVC modernes

• @Controller — indique qu'une classe gère des requêtes web et produit des vues.
• @RequestMapping — configure le mappage d'URL au niveau de la classe ou de la méthode.
• @RequestParam — extrait un paramètre de requête HTTP et le lie à un paramètre de méthode.
• @Autowired — injection automatique de dépendances (autowiring) utilisée pour lier les services et composants au moment du démarrage.

Utilisation des annotations

• @Controller remplace la déclaration explicite d'un bean contrôleur dans la configuration XML en permettant l'enregistrement automatique par le component scanning.
• @Service (ou @Component) marque les composants métiers qui, dans une configuration XML classique, seraient déclarés comme beans; le Spring Container gère leur cycle de vie et leur injection. L'injection se réalise fréquemment via @Autowired pour l'autowiring des dépendances entre contrôleurs, services et repositories.

Transition de la configuration XML vers les Annotations

La configuration basée sur XML reste pertinente pour des déploiements hérités, mais les annotations réduisent la verbosité et rapprochent la configuration du code métier. Migrer vers les annotations permet d'utiliser le component scanning, d'enregistrer automatiquement les beans et de centraliser moins de définitions XML. Les annotations @Controller et @RequestMapping remplacent les mappings XML, tandis que le Spring Container continue d'assurer la gestion des beans et de la Injection de dépendances.

Lors de la migration, conservez les fichiers XML critiques pour la configuration de contexte ou pour des comportements transverses, puis remplacez progressivement les définitions de beans par des annotations. L'adoption de Maven facilite cette transition grâce à la structure standardisée du projet et à la gestion déclarative des dépendances.

Architecture d'une application Spring Web MVC

Une application Spring Web MVC se compose classiquement de couches distinctes : contrôleurs (gestion des requêtes), services/managers (logique métier), DAO/repositories (accès aux données) et vues (JSP, Thymeleaf, etc.). Le DispatcherServlet orchestre le flux, le ViewResolver traduit les noms logiques de vues en ressources physiques, et le Spring Container fournit les beans à injecter. Cette séparation facilite les tests unitaires et l'évolution fonctionnelle tout en maintenant une cohérence entre code métier et configuration. Spring fonctionne en outre comme un conteneur léger (conteneur léger) responsable de la création, de l'initialisation et du cycle de vie des beans, sans imposer le poids d'un serveur d'applications complet.

La couche métier (Business Layer) regroupe les services et managers qui implémentent la logique métier, la gestion des transactions, la validation et les règles de domaine ; elle expose des interfaces testables et découple la logique métier des contrôleurs pour faciliter les tests unitaires et l'évolution fonctionnelle.

Maîtriser l'Inversion de Contrôle (IoC)

Le principe d'Inversion de Contrôle (IoC, ou Dependency Injection - DI) repose sur le fait que le framework (le Spring Container) crée et injecte les dépendances nécessaires aux composants de l'application, au lieu de laisser chaque classe instancier ses propres dépendances. L'utilisation de l'IoC simplifie les tests et améliore la modularité.

La Injection de dépendances se matérialise par l'injection par constructeur ou par setter, et peut être configurée via XML ou annotations. Comprendre ces modes d'injection permet de concevoir des composants découplés et réutilisables, essentiels pour des applications web évolutives.

📑 Sommaire du document

• Logiciels Prérequis
• Etape 1
• Etape 2
• Etape 3
• Etape 4

💡 Pourquoi choisir ce cours ?

Ce support de cours, issu du cursus de l'EISTI et signé par VILLETTE Charles et ses co‑auteurs, privilégie une mise en œuvre pas à pas plutôt que la seule théorie. L'atout principal est la granularité pratique : fichiers web.xml, springmvc-servlet.xml, build.xml et la liste explicite des jars permettent une installation reproductible. Les exemples concrets (HelloWorldController, CarListController, modèles Car/Brand) facilitent l'apprentissage par l'exercice et la mise en production locale sur Tomcat.

👤 À qui s'adresse ce cours ?

• Public cible : développeurs Java et étudiants en développement web souhaitant configurer et déployer une application Spring Web MVC simple sur Tomcat en utilisant Eclipse.
• Prérequis : maîtrise des bases du langage Java (Java 1.5 ou supérieur, JDK installé), connaissance élémentaire des servlets/JSP, familiarité avec Eclipse ou IntelliJ IDEA et notions d'Ant pour utiliser les fichiers build.xml. Une compréhension basique du packaging WAR et des opérations de déploiement facilite la mise en pratique.

❓ Foire Aux Questions (FAQ)

Comment le DispatcherServlet associe-t-il une URL à un contrôleur ? Le DispatcherServlet intercepte les requêtes mappées dans web.xml et utilise la configuration déclarée dans springmvc-servlet.xml ou les annotations pour résoudre le contrôleur correspondant. La résolution s'appuie sur les définitions de mapping et sur le ViewResolver pour produire ensuite la vue appropriée.

Quels jars sont nécessaires pour exécuter Spring Web MVC on Tomcat ? Dépendances principales : spring.jar, spring-webmvc.jar, standard.jar (jakarta-taglibs), commons-logging.jar, servlet-api.jar et jstl.jar. Ces bibliothèques couvrent le cœur Spring MVC, la gestion des tags JSP, le logging et les API servlet/JSP nécessaires à l'exécution.