Spring web MVC - sliders.alpha.free.frsliders.alpha.free.fr/EFREI/M1/EFREI M1/Cours Campus...

Benoît CHARROUX Spring

______________________________________________________________________________________________

1 / 26

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].


______________________________________________________________________________________________

2 / 26

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.

Figure 1

Couche métier

Couche service

Couche application

Couche présentation


______________________________________________________________________________________________

3 / 26

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.


______________________________________________________________________________________________

4 / 26

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é.


______________________________________________________________________________________________

5 / 26

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.


______________________________________________________________________________________________

6 / 26

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) :


______________________________________________________________________________________________

7 / 26

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é).


______________________________________________________________________________________________

8 / 26

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 :


______________________________________________________________________________________________

9 / 26

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'applicat ion 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.


______________________________________________________________________________________________

10 / 26

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.


______________________________________________________________________________________________

11 / 26

L’utilisation des formulaires HTML (côté View de MV C) 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.


______________________________________________________________________________________________

12 / 26

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; } }


______________________________________________________________________________________________

13 / 26

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.


______________________________________________________________________________________________

14 / 26

L’utilisation des formulaires (côté Controller de M VC) 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.

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.

Couche métier

Couche service

Couche application

Couche présentation

Couche View

Couche Controller


______________________________________________________________________________________________

15 / 26

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 c ommand, 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


______________________________________________________________________________________________

16 / 26

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 ?


______________________________________________________________________________________________

17 / 26

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">


______________________________________________________________________________________________

18 / 26

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 >


______________________________________________________________________________________________

19 / 26

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 >


______________________________________________________________________________________________

20 / 26

La chaîne de traitement pour construire un formulai re 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.

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.

Requête GET

referenceDate : voir plus haut.

Affichage de la vue


______________________________________________________________________________________________

21 / 26

Récupérer les données d'un formulaire qui a été remp li 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 >


______________________________________________________________________________________________

22 / 26

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 reques t) 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, BindE xception 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


______________________________________________________________________________________________

23 / 26

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 >


______________________________________________________________________________________________

24 / 26

La chaîne de traitement pour réceptionner un formul aire 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.

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.

Requête POST

onSubmit : retourne les données à afficher, précise quelle View utiliser…

Affichage de la vue

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.


______________________________________________________________________________________________

25 / 26

Afficher les données du formulaire, les erreurs app arues durant le traitement…

Spring MVC propose une balise bind qui peut être utilisée dans une page JSP. L’utilisation de bind… à venir.


______________________________________________________________________________________________

26 / 26

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/

Spring web MVC - sliders.alpha.free.frsliders.alpha.free.fr/EFREI/M1/EFREI M1/Cours Campus...

Documents

Transcript of Spring web MVC - sliders.alpha.free.frsliders.alpha.free.fr/EFREI/M1/EFREI M1/Cours Campus...