Vous êtes sur la page 1sur 26

Benoît CHARROUX

Spring

Spring web MVC


Ce tutorial est le quatrième d'une série consacrée à Spring. Les premiers tutoriaux ont
permis de développer une application complète qui utilise une base de données comme support
de persistance.

Rappel sur les objectifs de la série de tutoriaux


La série de tutoriaux n'a pas pour objectif de couvrir toutes les possibilités offertes par
Spring. Il y a pour cela des livres [1] ainsi que des manuels de référence [2]. A l'opposé de
l'approche exhaustive de ces ouvrages, qui requièrent d'emblée des connaissances avancées telles
que Struts, Hibernate..., les tutoriaux présentés ici nécessitent uniquement, à la base, une bonne
connaissance du langage Java Standard Edition. Puis, au fil des tutoriaux, les concepts de
persistance dans une base de données, de transaction, de sécurité... sont abordés. De plus, l'ordre
des tutoriaux suit le cycle de vie typique du développement d'un logiciel, qui commence bien
souvent par l'implantation de la partie métier d'une application, se poursuit par le développement
de la partie applicative, puis des services associés (la persistance...), de l'interface utilisateur, etc.
En plus de la maîtrise du langage Java, la lecture de ces tutoriaux nécessite un minimum de
connaissances dans la modélisation avec UML. Le lecteur qui souhaite acquérir des
connaissances sur UML pourra se référer à l'ouvrage [3].

______________________________________________________________________________________________

1 / 26
Benoît CHARROUX

Spring

Objectif du présent tutorial


Le but de ce cinquième tutorial est d’ajouter une couche de présentation à notre projet (voir
la figure 1). Pour cela nous allons mettre notre application en ligne sur un serveur Web, et la
rendre accessible par un client Web (qui s’exécute dans un navigateur). Cette couche de
présentation est développée à l’aide du framework Spring web MVC.

Couche présentation

Couche application

Couche métier

Couche service

Figure 1

______________________________________________________________________________________________

2 / 26
Benoît CHARROUX

Spring

Le modèle MVC (Model View Controller)


La plupart des framework de présentation utilisent le modèle MVC. Voici une définition de
ce modèle [4] :

It is common to split an application into separate layers that run on different computers:
presentation (UI), domain logic, and data access. In MVC the presentation layer is further
separated into view and controller.

MVC is often seen in web applications, where the view is the actual HTML page, and the
controller is the code that gathers dynamic data and generates the content within the HTML.
Finally, the model is represented by the actual content, usually stored in a database or in XML
nodes, and the business rules that transform that content based on user actions.

Though MVC comes in different flavors, control flow generally works as follows:

- The user interacts with the user interface in some way (e.g. presses a button).

- A controller handles the input event from the user interface, often via a registered handler
or callback.

- The controller notifies the model of the user action, possibly resulting in a change in the
model's state. (e.g. controller updates user's Shopping cart).[3]

- A view uses the model (indirectly) to generate an appropriate user interface (e.g. the view
produces a screen listing the shopping cart contents). The view gets its own data from the
model. The model has no direct knowledge of the view.

- The user interface waits for further user interactions, which begins then a new cycle.

______________________________________________________________________________________________

3 / 26
Benoît CHARROUX

Spring

Spring web MVC


Aujourd’hui, le framework le plus utilisé pour développer un couche de présentation
orienté Web en Java est incontestablement Struts [5]. Cependant, après plusieurs années
d’utilisation, il est aujourd’hui de plus en plus critiqué. D’autant plus que d’autres framework ont
vus le jour entre temps. Parmi eux, Spring MVC s’avère prometteur [5]. Voici à titre d’exemple
quelques fonctionnalités importantes de Spring MVC :

- de simples objets Java peuvent être utilisés pour renseigner ou extraire les données d’un
formulaire dans une page Web ;

- permet de changer ou d’utiliser conjointement différentes technologies pour la couche


View (JSP, XSLT, PDF, Excel…)

Cependant, malgré ces propriétés alléchantes, bien malin qui peut dire aujourd’hui si
Spring MVC aura le succès de Struts ?

Matériel requis
Spring MVC fait partie intégrante du framework Spring. Il n’est donc pas nécessaire de
télécharger une extension supplémentaire. En revanche, un serveur Web est indispensable pour
réaliser ce tutorial. Nous utilisons ici le fameux couple Apache/Tomcat [7]. Apache est un
serveur Web, et Tomcat est essentiellement un moteur de Servlet [8]. Une phrase extraite d'un
article de Wikipédia résume assez bien ce qu'est une Servlet :

The Java Servlet API allows a software developer to add dynamic content to a Web server using
the Java platform. The generated content is commonly HTML, but may be other data such as
XML.

Spring MVC, comme de nombreux framework de présentation, utilise une Servlet qui
oriente les requêtes venant d’un client Web vers un Controller (au sens MVC du terme). Ce
dernier a pour rôle de traiter la requête.

Ici, c'est la version 5.5 de Apache/Tomcat que nous utilisons. Après l'avoir téléchargée, son
installation se limite à la décompression du fichier compressé.

______________________________________________________________________________________________

4 / 26
Benoît CHARROUX

Spring

Configuration d'Eclipse

Apache/Tomcat peut être piloté à partir d'Eclipse. Pour cela il faut indiquer à Eclipse où
trouver ce serveur sur votre machine : afficher la fenêtre suivant à partir du menu Windows-
>Preference.

Pour faire apparaître Apache/Tomcat en tant que Server runtime environment, cliquez sur
le bouton Add, puis sélectionnez ce serveur comme suit.

______________________________________________________________________________________________

5 / 26
Benoît CHARROUX

Spring

Création d'un projet Eclipse


Nous pouvons passer à présent à la création d'un projet Eclipse (menu File-> New ->
Other-> Web -> Dynamic Web Project) :

______________________________________________________________________________________________

6 / 26
Benoît CHARROUX

Spring
En cliquant sur suivant, vous pourrez donner un nom à votre projet et le placer à l'endroit
de votre choix sur votre machine (vérifier toutefois que Apache/Tomcat a bien été sélectionné).

______________________________________________________________________________________________

7 / 26
Benoît CHARROUX

Spring
En passant à l'écran suivant il faut faire attention au choix du Context Root car c'est le
chemin qui permettra à un utilisateur d'accéder à votre application via un navigateur Web.

Par exemple en donnant rss comme Context Root, l'utilisateur devra écrire une url comme
suit :

______________________________________________________________________________________________

8 / 26
Benoît CHARROUX

Spring
Pour terminer la configuration d'Eclipse, il faut y ajouter toutes les librairies dont nous
aurons besoin. Contrairement à un projet Java, les librairies d'un projet Web dynamique doivent
être placées dans un sous répertoire WebContent\WEB-INF\lib de votre application :

Toutes ces librairies se trouvent dans le répertoire d'installation de Spring. Attention


cependant, le projet qui est présenté ici est un projet complet qui, en plus des couches MVC,
contient aussi les couches services, métier et application. Il utilise donc d'autres librairies que
celles indiquées à la figure ci-dessus. Le paragraphe suivant indique où trouver un fichier
compressé qui contient toutes les librairies du projet.

Récupération des codes sources et test de l'application


Les fichiers sources de l'application peuvent être récupérés à l'adresse :

http://perso.efrei.fr/~charroux/spring/

Vous y trouverez le fichier springMVC.rar. Ce fichier contient deux autres fichiers


compressés :

– src.rar contient les fichiers sources des couches services, métier, application et Controller ;
– WebContent.rar contient les fichiers sources de la couche View (des pages JSP), les librairies
utiles au projet...

Le contenu de src.rar doit prendre la place du répertoire src dans votre projet Eclipse. Le
contenu de WebContent.rar doit quant à lui prendre la place du répertoire WebContent. Utilisez
éventuellemet la touche F5 sous Eclipse pour rafraichir le projet.

______________________________________________________________________________________________

9 / 26
Benoît CHARROUX

Spring
Pour tester l'application, il faut commencer par démarrer le serveur de base de données
(HSQLDB), puis Apache/Tomcat. HSQLDB peut être démarré en ligne de commande (placez-
vous dans le répertoire qui contient les librairies de votre projet) :

Pour démarrer Apache/Tomcat et y déployer l'application, commencez par faire apparaître


l'onglet Servers dans Eclipse (menu Windows -> Show View -> Other -> Servers), puis ajoutez à
l'onglet qui apparaît Apache/Tomcat sans oublier d'associer votre projet à Apache/Tomcat (clic
droit sur Apache/Tomcat suivi de Add and Remove Projects...). Démarrez alors le serveur
(bouton Start the server à droite de l'onglet Servers)... après quelques instants, la console vous
indique que votre application a été déployée dans le serveur. Il ne vous reste plus qu'à lancer un
navigateur Web et à saisir la bonne url :

Après vous être amusé avec l'application, nous pouvons passer à l’étude de Spring MVC.

______________________________________________________________________________________________

10 / 26
Benoît CHARROUX

Spring

L’utilisation des formulaires HTML (côté View de MVC)


Les formulaires sont les formes les plus utilisées pour recueillir les informations venant
d’un utilisateur. Avec les formulaires, deux problèmes récurrents se posent :

- comment pré-remplir un formulaire avant de l’envoyer à l’utilisateur ?


- comment récupérer les données du formulaire une fois qu’il a été renseigné et posté par
l’utilisateur ?

Commençons par le premier point : pré-remplir un formulaire avant de l’envoyer à


l’utilisateur. Voici un exemple de formulaire tiré de notre application de gestion de flux RSS.

On y voit un menu déroulant dans lequel l’utilisateur peut choisir une catégorie. Il dispose
aussi d’un champ de saisie pour donner le titre d’un canal RSS, et d’un bouton de validation.

______________________________________________________________________________________________

11 / 26
Benoît CHARROUX

Spring
Voici le code HTML de ce formulaire tel qu’il est interprété sur le poste de l’utilisateur.

<form id="category" action="channelChanged.action" method="POST">

Création d'un nouveau channel RSS :<br>

Titre du channel : <input type=text name="channelTitle"/><br>

Categorie :
<select id="name" name="name">
<option value="Sport">Sport</option>
</select><br>

<input type="submit" name="submit" value="Ajouter ce channel"/>

</form>

Dès que la page s’affiche, le menu déroulant est pré-rempli avec l’ensemble des catégories
possibles. Ce remplissage s’est fait côté serveur avant que le formulaire ait été envoyé vers le
client. Plusieurs technologies permette de construire dynamiquement une page HTML. Nous
utilisons dans ce tutorial la technologie Java Server Pages (JSP) qui est, de loin, la plus utilisée
[9]. Spring permet néanmoins d’utiliser d’autres technologies d’affichage telles que XSLT, PDF,
Excel…, mais nous ne les abordons pas ici.

Les JSP peuvent être vues comme le passage du monde Java au monde du Web et de
l’HTML. Côté Java, et plus particulièrement côté Java Spring, les données d’un formulaire sont
de simples objets appelés des « commands ». Voici par exemple la classe qui contient une
catégorie RSS.
public class RssCategory {

private String name;

public RssCategory(){
}
public RssCategory( String name ){
this.name = name;
}
public String getName() {
return name;
}
}

______________________________________________________________________________________________

12 / 26
Benoît CHARROUX

Spring
Pour passer du monde Java au monde HTML, le programmeur doit écrire une page JSP qui
fait référence aux données Java du formulaire. Voici le code de la page JSP qui sert à générer
dynamiquement la page html donnée en début de paragraphe (les pages JSP sont dans le sous-
répertoire WebContent\WEB-INF\jsp de votre projet) :
<form:form action="channelChanged.action" method="POST"
commandName="category">

Création d'un nouveau channel RSS :<br>

Titre du channel : <input type=text name="channelTitle"/><br>

Categorie :
<form:select path="name">
<form:options items="${allCategories}" itemValue="name"
itemLabel="name"/>
</form:select><br>

<input type="submit" name="submit" value="Ajouter ce channel"/>

</form:form>

Les pages HTML et JSP sont semblables sauf pour quelques parties :

<form:select path="name">
<form:options items="${allCategories}" itemValue="name" itemLabel="name"/>
</form:select>

Où les instructions form:select et form:options sont des tag propres à Spring.

C'est Spring qui se charge de remplacer itemValue par une catégorie existante telle Sport
par exemple. Il faut cependant quitter le niveau View et « descendre » au niveau Controller pour
étudier comment Spring procède. Cela fait l'objet du paragraphe suivant.

______________________________________________________________________________________________

13 / 26
Benoît CHARROUX

Spring

L’utilisation des formulaires (côté Controller de MVC)


Pour Spring, un Controller au sens MVC du terme est une classe Java. Spring fournit de
nombreux Controllers. Parmi les plus importants on trouve les Controllers qui servent à gérer des
formulaires. Leur rôle est alors essentiellement d'interroger les couches basses de l'application, de
récupérer des données à afficher, et de les transmettre à la couche View. Voici un schéma qui
montre toute les couches d'une application.

Couche présentation

Couche View

Couche Controller

Couche application

Couche métier

Couche service

On y voit que la couche View dépend (reçoit ses données) de la couche Controller, qui
dépend elle même de la couche application. La couche Model au sens MVC du terme ne figure
pas sur le schéma car elle est constituée d'objets qui transitent entre les couches View et
Controller.

______________________________________________________________________________________________

14 / 26
Benoît CHARROUX

Spring
Voici le code de la classe Controller associée à la page JSP du paragraphe précédent (code
présent dans le sous-répertoire src\rss\presentation\web de votre projet).
public class ChannelController extends SimpleFormController{

private CategoryManager categoryManager = null;

public void setCategoryManager(CategoryManager categoryManager) {


this.categoryManager = categoryManager;
}

protected Map referenceData(HttpServletRequest request, Object command,


Errors errors) throws Exception{

List<RssCategory> categories =
categoryManager.getAvailableCategories();
Map<String,Object> model=new HashMap<String,Object>();
model.put("allCategories", categories);
return model;
}
}

Cette classe hérite de SimpleFormController qui est fournit par Spring. Pour adapter le
comportement de SimpleFormController à chaque formulaire, il faut en surcharger les
méthodes. On voit ici qu'il n'est nécessaire de surcharger qu'une seule méthode : referenceData.
Dans cette méthode, on interroge la couche application à la recherche de la liste de catégories
RSS

List<RssCategory> categories = categoryManager.getAvailableCategories();

puis on créé une table de hachage ayant pour clef allCategories et pour valeur la liste
des catégories. Cette table de hachage sera transmise automatiquement à la couche View lorsque
Spring appellera une des méthodes de la classe SimpleFormController, showForm par
exemple:

protected ModelAndView showForm( ...) throws Exception

Cette méthode retourne un objet du type ModelAndView qui sera créé dans la méthode via le
constructeur suivant par exemple :

public ModelAndView(String viewName, Map model)

On y retrouve notre table de hachage ainsi qu'un simple nom pour la View. Ainsi, pour
Spring, une View est identifiée par un simple nom et on lui transmet une table de hachage qui
contient les données à afficher. C'est un point important dans la compréhension de Spring MVC
car c'est ainsi que Spring assure une indépendance entre les technologies d'affichage des View et

______________________________________________________________________________________________

15 / 26
Benoît CHARROUX

Spring
les Controllers. Le but étant de pouvoir changer de technologies d'affichage, passer de JSP à PDF
par exemple, en conservant les Controllers.

Ainsi les données à afficher sont transmises via une table de hachage à la View, mais
plusieurs questions se posent :

– comment lire dans la page JSP les valeurs contenues dans la table de hachage fournit par le
Controller ?

– de façon plus général, comment associer un Controller avec une technologie particulière pour
la View comme JSP ?

– et enfin, comment associer un Controller précis avec une page JSP précise ?

______________________________________________________________________________________________

16 / 26
Benoît CHARROUX

Spring

Comment lire dans un page JSP les valeurs de la table de hachage fournit par le Controller ?

Dans notre cas, la table de hachage contient une liste de RssCategory :

List<RssCategory> categories = categoryManager.getAvailableCategories();


Map<String,Object> model=new HashMap<String,Object>();
model.put("allCategories", categories);

Ces instructions figurent dans le Controller. RssCategory contient les données du


formulaire. Dans le jargon de Spring, une telle classe est appelée une « command ». Cette classe
peut être transmise par programmation au Controller, mais pour rester dans la philosophie de
Spring, il est bien plus commode de la déclarer en XML (fichier action-servlet.xml dans le sous-
répertoire WebContent\WEB-INF de votre projet) :

<bean id="channelController" class="rss.presentation.web.ChannelController">


...
<property name="commandName" value="category"/>
<property name="commandClass" value="rss.application.RssCategory"/>
</bean>

commandClass permet de choisir la classe qui va servir à créer l'objet associé au formulaire
(la classe RssCategory). commandName permet de changer le nom par défaut de l'objet Java qui
contient les données du formulaire. Ici, c'est le nom category qui est donné. Le programmeur de
la page JSP doit utiliser ce nom dans le tag form s'il veut récupérer les valeur de la table de
hachage :

<form:form ... commandName="category">

______________________________________________________________________________________________

17 / 26
Benoît CHARROUX

Spring
De la même façon, la clef allCategories de la table de hachage peut-être utilisée dans la
View pour récupérer les données à afficher comme le montre l'extrait suivant de notre page JSP :

<form:select path="name">
<form:options items="${allCategories}" itemValue="name" itemLabel="name"/>
</form:select>

où <form:select path="name"> est « mappé » avec l'attribut name de la classe


RssCategory (c'est à dire que Spring appelera la méthode getName pour récupérer la valeur du
nom):

public class RssCategory {

private String name;

public RssCategory(){
}
public RssCategory( String name ){
this.name = name;
}
public String getName() {
return name;
}
}

Comment associer un Controller avec une technologie de View ?

Dans ce tutorial, nous utilisons JSP comme technologie de. Le choix de cette technologie se
fait dans le fichier fichier action-servlet.xml (sous-répertoire WebContent\WEB-INF de votre
projet) par les déclarations suivantes :

<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
lazy-init="default" autowire="default" dependency-check="default">

<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix">
<value>/WEB-INF/jsp/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>

______________________________________________________________________________________________

18 / 26
Benoît CHARROUX

Spring
La propriété viewClass indique que c'est la technologie JSLT qui est choisie [10] . La
propriété prefix indique le répertoire où trouver les pages JSP, tandis que suffix donne
l'extension des fichiers JSP.

Comment associer un Controller avec une page JSP ?

Pour assurer une idempotence entre le Controller et la page JSP correspondante, cette
dernière peut être simplement nommée lors de la déclaration du Controller :

<bean id="channelController" class="rss.presentation.web.ChannelController">


<property name="categoryManager" ref="categoryManager" />
<property name="formView" value="ChannelManager"/>
</bean>

où c'est la ligne suivante qui permet de donner un nom à la View :

<property name="formView" value="ChannelManager"/>

grâce à cette déclaration, Spring appellera automatiquement la méthode suivante de la


classe SimpleFormController

public final void setFormView(String formView)

La ligne <property name="categoryManager" ref="categoryManager" /> permet


quant à elle d'intégrer les couches Controller et application. En effet, categoryManager est un
autre bean Spring déclaré de la façon suivante (voir le tutorial SpringApplication) :

<bean id="categoryManager" class="rss.application.impl.CategoryManagerImpl">


<property name="categoryDAO">
<ref bean="categoryDAO"/>
</property>
</bean>

______________________________________________________________________________________________

19 / 26
Benoît CHARROUX

Spring

La chaîne de traitement pour construire un formulaire


Dans l'exemple présenté ici, nous n'utilisons qu'une petite partie du potentiel de la classe
SimpleFormController. En fait, cette classe contient de nombreuses méthodes qu'il suffit de
surcharger pour changer leurs comportements par défaut. Ces méthodes sont appelées par le
framework Spring dans un ordre bien précis.

Requête GET

fromBackingObject : retourne un objet qui


contiendra des données utilisées par le
formulaire.

initBinder : permet de transformer des type


quelconques (par exemple le type java.util.Date) en
une chaîne de caractères affichable en HTML.

onBindOnNewForm : permet de remodifier les


données du formulaire qui ont été initialisées lors de la
transmission de la requête.

referenceDate : voir plus haut.

Affichage de la vue

______________________________________________________________________________________________

20 / 26
Benoît CHARROUX

Spring

Récupérer les données d'un formulaire qui a été rempli et posté


Considérons à présent le cas où un utilisateur rempli le formulaire suivant, puis clique sur
le bouton Ajouter de channel.

Comme indiqué dans le code HTML de cette page, les données de ce formulaire seront
traitées une fois reçues sur le serveur par un Controller associé au nom channelChanged.action.

<form id="category" action="channelChanged.action" method="POST">...

Associer un Controller à un nom est réalisé simplement en XML de la façon suivante dans
le fichier ... :

<bean id="handlerMapping"

class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/channelChanged.action">channelChangedController</prop>
</props>
</property>
</bean>

______________________________________________________________________________________________

21 / 26
Benoît CHARROUX

Spring
où channelChangedController doit être déclaré en tant que bean Spring :

<bean id="channelChangedController"
class="rss.presentation.web.ChannelChangedController">
<property name="channelManager" ref="channelManager" />
<property name="formView" value="Confirmation"/>
<property name="commandName" value="channel"/>
<property name="commandClass" value="rss.application.RssChannel"/>
</bean>

Voici le code du Controller correspondant :


public class ChannelChangedController extends SimpleFormController{

ChannelManager channelManager;

public void setChannelManager(ChannelManager channelManager) {


this.channelManager = channelManager;
}

protected Object formBackingObject(HttpServletRequest request) throws


Exception{
String channelTitle = request.getParameter("channelTitle");
String categoryName = request.getParameter("name");
RssCategory category = new RssCategory( categoryName );
RssChannel channel = new RssChannel(channelTitle, category);
return channel;
}

protected ModelAndView onSubmit(HttpServletRequest request,


HttpServletResponse response, Object command, BindException errors) throws
Exception{
RssChannel channel = (RssChannel)command;
String action = request.getParameter("submit");
if( action.equals("Ajouter ce channel") ){
channelManager.addChannel(channel.getTitle(),
channel.getCategory().getName());
}
return this.showForm(request, response, errors);
}
}

On y voit qu'ici encore notre Controller hérite de SimpleFormController. Ainsi, le


remplissage d'un formulaire côté serveur et son envoi vers le client via une primitive HTTP GET,
ou le traitement d'un formulaire rempli côté client et reçu sur le serveur via une primitive POST,
sont opérés dans des classes héritant toutes de SimpleFormController. Cependant, ici, ce sont
les méthodes formBackingObject et onSubmit qui sont surchargées. formBackingObject

______________________________________________________________________________________________

22 / 26
Benoît CHARROUX

Spring
permet d'initialiser et de retourner un objet Java avec les données du formulaire. Les données du
formulaire sont extraites de la requête HTTP via la méthode getParameter comme dans

String channelTitle = request.getParameter("channelTitle");

où channelTitle correspond au champs de saisie suivant dans le code HTML

<input type=text name="channelTitle"/>

La méthode onSubmit est utilisée si les données du formulaire sont considérées comme
correctes pour transmettre des informations à la couche View. Le paramètre command correspond
à l'objet Java contenant les données du formulaire retourné par la méthode formBackingObject.
C'est dans la méthode onSubmit que l'appel des méthodes de la couche application est réalisé à
partir de l'objet Java correspondant au formulaire :

channelManager.addChannel(channel.getTitle(),
channel.getCategory().getName());

Comme précédemment, le nom de la View qui va s'afficher une fois le traitement achevé
est initialisé en XML (voir la ligne <property name="formView" value="Confirmation"/>) :

<bean id="channelChangedController"
class="rss.presentation.web.ChannelChangedController">
<property name="channelManager" ref="channelManager" />
<property name="formView" value="Confirmation"/>
<property name="commandName" value="channel"/>
<property name="commandClass" value="rss.application.RssChannel"/>
</bean>

______________________________________________________________________________________________

23 / 26
Benoît CHARROUX

Spring
La chaîne de traitement pour réceptionner un formulaire rempli et posté
Tout comme avec la primitive GET, l'exemple présenté n’utilise qu'une petite partie du
potentiel de la classe SimpleFormController. En fait, cette classe contient de nombreuses
méthodes qu'il suffit de surcharger pour changer leur comportement par défaut. Ces méthodes
sont appelées par le framework Spring dans un ordre bien précis.

Requête POST

fromBackingObject : retourne un objet qui


contiendra des données utilisées par le
formulaire.

initBinder : permet de transformer des type


quelconques (par exemple le type java.util.Date) en
une chaîne de caractères affichable en HTML.

onBind : même fonctionnalité que onBindOnNewForm.

onBindAndValidate : permet de valider les données


d’un formulaire, spécifier des erreurs…

processFormSubmission : permet de traiter les données


soumises et de les réafficher si des erreurs se sont
produites.

onSubmit : retourne les données à


afficher, précise quelle View utiliser…

Affichage de la vue

______________________________________________________________________________________________

24 / 26
Benoît CHARROUX

Spring
Afficher les données du formulaire, les erreurs apparues durant le
traitement…
Spring MVC propose une balise bind qui peut être utilisée dans une page JSP. L’utilisation
de bind… à venir.

______________________________________________________________________________________________

25 / 26
Benoît CHARROUX

Spring

Bibliographie

[1] Spring par la pratique. Julien Dubois, Jean-Philippe Retaillé, Thierry Templier. Heyrolles 2008.
[2] http://www.springframework.org/documentation
[3] UML 2, pratique de la modélisation. 2 ième édition. Benoît Charroux, Aomar Osmani, Yann Thierry-Mieg.
Pearson Education.
[4] http://en.wikipedia.org/wiki/Model-view-controller
[5] http://en.wikipedia.org/wiki/Apache_Struts
[6] http://static.springframework.org/spring/docs/2.5.x/spring-reference.pdf
[7] http://tomcat.apache.org/
[8] http://en.wikipedia.org/wiki/Java_Servlet
[9] http://en.wikipedia.org/wiki/JavaServer_Pages
[10] http://java.sun.com/products/jsp/jstl/

______________________________________________________________________________________________

26 / 26