Débuter avec Spring MVC 3.0. Partie 1 : Configuration

Plusieurs Frameworks tels Struts ou Click proposent d'offrir aux développeurs une meilleure structuration de la partie présentation de leurs applications J2E. Basé sur le patron de conception MVC 2 (un contrôleur façade unique, utilisation d'un modèle pour la sélection et la construction de la vue), Spring MVC offre une alternative intéressante en profitant à la fois des avantages d'un conteneur léger, d'une grande flexibilité permettant entre autres de séparer logiquement les composants et changer plus facilement de technologies coté client sans impacter les contrôleur. Mais surtout, à partir de la version 2.5, Spring MVC utilise les annotations Java 5, ce qui simplifie l'utilisation des contrôleurs, facilite les tests unitaires et permet de masquer l'utilisation de l'API servlet.

Cette série d'articles, s'adressant à un débutant en Spring ayant déjà une expérience avec les technologies WEB de présentation (comme WebWork, JSP, JSF, Struts3, ...) sachant configurer une application web,  sera présentée sous forme de brefs tutoriels afin de passer en revue les principaux comportements de Spring MVC sans entrer dans les détails complexes. Pour des explications plus poussées vous pouvez vous référer à l'excellent ouvrage « Spring Par La Pratique » (2e Édition) aux éditions Eyrolles et à la documentation officielle de Spring à savoir :

- Web Spring MVC Framework
- Spring MVC API

Dans le présent article il s'agira de mettre en place l'environnement permettant d'exécuter des tests et d'effectuer l'affichage d'une simple page d'accueil.

Pour suivre ce tutoriel je préconise l'utilisation d'un JDK 1.5 (ou plus), un tomcat 5.5 (ou plus), et un Eclipse 3.2.0 (ou plus).

Les bibliothèques utilisées pour les premiers tutoriels et à ajouter (au pom.xml ou directement sous forme de JAR dans le dossier WEB-INF/lib) du projet web sont :
- aopalliance-1.0
- commons-logging-1.1.1
- servlet-api-2.4
- spring-beans-3.0.4
- spring-context-3.0.4
- spring-context-support-3.0.4
- spring-core-3.0.4
- spring-web-3.0.4
- spring-webmvc-3.0.4


Voici le cycle de vie des processus de Demande de Spring 3.0 MVC:

  • Le client envoie une requête Http au conteneur Web.
  • Cette requête entrante est interceptée par le DispatcherServlet (contrôleur frontal) qui tente alors de faire le mapping. En fonction des règles définies, le DispatcherServlet envois la requête au contrôleur approprié.
  • Le contrôleur traite la demande et retourne le modèle et la vue (sous forme d'une d'instance d'objet ModelAndView) au contrôleur frontal.
  • Le contrôleur résout finalement la vue, dans notre cas une page JSP (on pourrait aussi bien utiliser Velocity ou Freemarker) en consultant l'objet View Resolver (configurable depuis la servlet).
  • La vue sélectionnée est enfin rendu envoyé au client.

Configurer le contrôleur frontal (web.xml) :

Le contrôleur de façade se configure depuis le fichier web.xml, le point d'entrée est une servlet DispatcherServlet (qui implémente une HttpServlet classique). Dans ce tutoriel la configuration adoptée est la suivante :

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns
="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation
="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id
="WebApp_ID" version="2.5">

<display-name>SpringMVC</display-name>

<welcome-file-list>
<
welcome-file>index.html</welcome-file>
</
welcome-file-list>

<servlet>
<
servlet-name>SpringMVC</servlet-name>
<
servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<
load-on-startup>1</load-on-startup>
</
servlet>

<!-- Spring Mapping -->

<servlet-mapping> <!-- index page mapping -->
<
servlet-name>SpringMVC</servlet-name>
<
url-pattern>/index.html</url-pattern>
</
servlet-mapping>

<servlet-mapping> <!-- default mapping -->
<
servlet-name>SpringMVC</servlet-name>
<
url-pattern>/</url-pattern>
</
servlet-mapping>

<servlet-mapping> <!-- html mapping -->
<
servlet-name>SpringMVC</servlet-name>
<
url-pattern>*.html</url-pattern>
</
servlet-mapping>

</web-app>
Les balises <servlet-mapping> définissent des patterns pour que le DispatcherServlet puisse mapper les adresses url (ici l'index, la racine et toutes les adresses finissants par .html) vers le bon contrôleur frontal.

On retrouve aussi notre servlet DispatcherServlet dont le contenu de la balise <servlet-name> sera utilisé comme préfixe pour rechercher un fichier de configuration [servlet-name]-servlet.xml (ici SpringMVC-servlet.xml) à placer dans le répertoire WEB-INF du projet, ce fichier permet de configurer les beans du contrôleur.


Configuration du fichier SpringMVC-servlet.xml :

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:context="http://www.springframework.org/schema/context"
xmlns
="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util
="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc
="http://www.springframework.org/schema/mvc"
xsi:schemaLocation
="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
">

<!-- Using annotations -->

<context:annotation-config />
<
context:component-scan base-package="com.ideo.springmvc.web" />
<
bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
<
bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<
mvc:annotation-driven />

<!-- Naming View Configuration -->

<bean id="viewResolver1"
class
="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix
="/jsp/" p:suffix=".jsp" /> <!-- Prefix and suffix of the jsp models -->

<bean id="viewResolver2"
class
="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix
="/" p:suffix=".jsp" />

</beans>

Après déclaration des schémas xsld, il faut définir les contextes et initialiser le contexte de l'application, voici quelques explications :

<context:annotation-config> :  Utilisation des annotations pour l'injection de dépendances (indépendante des annotations de bean).

<context:component-scan> :  Les paquetages (et implicitement récursivement les sous-packages) à parcourir et dans lesquels se trouvent les composants Spring MVC annotés

<mvc:annotation-driven> :  Avec les beans DefaultAnnotationHandlerMapping et AnnotationMethodHandlerAdapter ceci permet entre autre l'utilisation des annotations Spring 3.0 (de gérer des validateurs sur des formats comme les dates, etc...). Pour plus d'informations à ce sujet, se référer à la section 15.12 Configure Spring MVC de la documentation officielle.

Enfin les ViewResolver permettent d'indiquer des règles à appliquer par les contrôleurs afin de résoudre les vues,  par exemple le bean viewResolver1 de compléter la recherche des pages jsp coté serveur en ajoutant un préfixe /jsp/ et un suffixe .jsp (ceci n'étant bien sur pas visible coté client et permettant juste de simplifier le code à écrire dans les contrôleurs).

Le contrôleur de la page d'index (IndexController.java) :

Afin de tester la bonne configuration de l'environnement, créer un fichier IndexController.java dans le package com.ideo.springmvc.web.controller contenant le code suivant :

package com.ideo.springmvc.web.controller;
import
org.springframework.stereotype.Controller;
import
org.springframework.web.bind.annotation.RequestMapping;
import
org.apache.commons.logging.Log;
import
org.apache.commons.logging.LogFactory;

@Controller
public
class IndexController {

protected final Log logger = LogFactory.getLog(getClass());

@RequestMapping("index")
public
String showIndex () {
logger
.info("Return Index View");
return
"index";

}

}

Le comportement des contrôleurs sera expliqué dans le prochain article..

La page d'index (index.jsp) :

Créer un fichier index.jsp dans le répertoire /webapp/jsp/, ce fichier contient le code suivant

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>
<
title>Index</title>
</
head>

<body>
<
h1>Spring MVC Index</h1>
</
body>

</html>

Lancer ensuite le serveur d'application comme pour n'importe quelle webapp et tester, le texte "Spring MVC Index" devrait s'afficher dans votre navigateur.

A suivre...

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.