Java Server Faces et Struts

Auteur :
Laura Zunarelli
Etudiante en Master 2ème année professionnel Génie Informatique en apprentissage
Mail : [e-mail]
Synthèse réalisée dans le cadre de l’U.E. : Etude et Projet d’Intergiciels

Résumé :
De nos jours, il existe de plus en plus d’applications web et celles-ci sont de plus en plus
compliquées. C’est pourquoi afin d’aider leur développement, on utilise des frameworks. Ces
frameworks permettent d’assurer l’évolution et la fiabilité de ces applications web.
Struts et JavaServerFaces (JSF) sont des standards parmi les frameworks de ce type.
En s’appuyant sur le modèle MVC ils permettent une meilleure séparation entre les
métiers d’informaticiens et ceux d’infographistes.
Actuellement, la plupart des applications web utilisent Struts ou JSF voir les deux…
Devenus incontournables dans ce domaine, nous allons, au cours de ce document, explorer
plus en détails ces deux frameworks.
Mots clés :
Struts, JavaServerFaces, JSF, framework, modèle MVC, applications web.
Abstract:
Nowadays, there is more and more web applications and they are more and more
complicated. That’s why, to help their development, we use frameworks. These frameworks
enable to ensure web application reliability and evolving.
Struts and JavaServerFaces (JSF) are standards among these frameworks. Based on the
MVC model, they enable a better separation between computer scientists and infographists.
Currently, the majority of web applications use Struts or JSF or the two…
Became inescapable in this domain, during this document, we explore in more details
these two frameworks.
Key Words:
Struts, JavaServerFaces, JSF, framework, MVC model, web applications.

Introduction :
Ce document porte sur deux frameworks standards pour la construction d’applications
web : Struts et JavaServerFaces. Après une brève introduction sur les frameworks,
l’application du modèle MVC dans Struts et dans JavaServerFaces (JSF) sera expliquée. Puis
chacun des deux frameworks seront explorés plus en détails. Pour conclure, une constatation
sur les principales différences entre ces deux frameworks et sur leur futur sera dressée.
1. Les frameworks
Avant l’arrivée des frameworks, le développement d'applications Web était simplement
constitué d’une page HTML et d’un navigateur. Aujourd'hui nous sommes confrontés au
développement d'applications bien plus complexes. Pour cela nous utilisons des frameworks.
Ces frameworks, ou : « cadre de conception » sont des espaces de travail modulaire. Il
s’agit d’un ensemble de bibliothèques, d'outils et de conventions permettant le développement
rapide d'applications. Leur but est d’accroître la productivité des développeurs dans le
développement des interfaces utilisateurs, en fournissant une architecture facilitant leur
maintenance. Ils permettent donc d’améliorer la réutilisabilité des applications, d’en accroître
la fiabilité, de diminuer les coûts et délais de développement et d’assurer leur évolutivité.
Avec leur apparition, de nombreux outils ont vu le jour. Parmi eux, Struts et JavaServerFaces
(JSF). Ceux-ci constituent aujourd’hui les deux standards dans le domaine de la conception
d’applications web. Ce sont ces deux standards que nous allons donc étudier plus en détails…
2. JSF, Struts, et le Modèle MVC
a) Le modèle MVC
L’un des principaux atouts de ces deux frameworks est l’utilisation du patron de
conception MVC (Modèle, Vue, Contrôleur). Celui-ci, leur permet de mieux dissocier les
métiers d’infographistes et d’informaticiens. En effet, ce modèle d’architecture est constitué
de trois parties. La première : le contrôleur, reçoit les actions de l’utilisateur et gère la
répartition des traitements entre la vue et le modèle. C’est cette partie qui gère toutes les
entrées de l’application. Le modèle représente la partie métier de l’application : on y retrouve
les états et la logique de l’application. La dernière partie : la vue, est la partie graphique
destinée aux infographistes, dans laquelle seul l’affichage est géré.
b) L’application du modèle MVC dans Struts et JavaServerFaces
Le framework Struts est construit autour d’un puissant contrôleur, tandis que JSF, est
principalement dédié à la couche vue.
Craig McClanahan est le créateur de Struts et l’un des principaux acteurs de JSF. Il a donc
occupé une place importante pour la création de ces deux frameworks, et est bien placé pour
dire que JSF et Struts sont différents mais ne sont pourtant pas incompatibles. Il a ainsi
suggéré une méthode d’intégration afin de combiner les deux frameworks. Le but étant de
combiner les avantages de chacun.
Cependant, Struts et JavaServerFaces n’ont pas été conçus de prime abord pour
fonctionner ensemble dans une même application. En effet, Struts propose des tags libs pour
la gestion des vues et une définition de la navigation au travers des pages. JSF, lui, fournit un
manageur des cycles de vie de l’application au travers de servlets de contrôle.

3. Présentation de Struts
a) Présentation générale
Struts, fut le premier des deux frameworks à arriver sur le marché. Apparu en 1998, il eu
beaucoup de succès. Compatible avec la plate-forme J2EE de Sun, Struts fait parti du projet
Jakarta (mené par l'ASF, l'Apache Software Foundation). L'adresse officielle de Struts est :
http://jakarta.apache.org/struts.
Le succès de ce framework repose sur sa capacité à répondre aux besoins des
développeurs actuels en termes de création d'applications et en termes de rapidité de mise en
œuvre. Struts est une combinaison des servlets Java, des JSP, des balises personnalisées et des
ressources messages qui forment une base unifiée. Struts est puissant, répandu, et mature. Dès
son arrivée, il a su s’imposer pour les applications de grandes tailles. Cependant son
utilisation de nos jours perd tout son sens pour les applications simples. En effet, pour les
petites applications, l’application de Struts pourrait prendre bien plus de temps que la
construction de l’application elle-même…
b) Principes de mise en œuvre de Struts
Une application basique de Struts est composée des trois parties du modèle MVC. Ces
trois parties sont généralement situées dans trois dossiers différents. Les pages jsp exploitent
des balises personnalisées de Struts :
Exemple : <%@ taglib prefix="s" uri="/struts-tags" %>
Il est cependant conseillé d’utiliser aussi la bibliothèque JSTL.
Les servlets sont utilisées de manière transparente via des classes.
La structure de l’application web doit être décrite dans un fichier: struts.xml. Ce fichier
contient toutes les règles de navigations nécessaires à l’application.
Exemple :
<action name="HelloWorld" class="example.HelloWorld">
<result>/example/HelloWorld.jsp</result>
</action>
Dans cet exemple, en tapant l’adresse pour accéder à la page de bienvenue dans le
navigateur, une redirection sera effectuée pour consulter la page HelloWorld à la place.
c) Les bibliothèques de Struts:
Voici un petit résumé des bibliothèques que l’on retrouve dans Struts :
 Les librairies Struts*.jar: contiennent les classes java distribuées par le projet Struts.
 Les fichiers commons*.jar sont utilisés par l’implémentation.
 Les autres fichiers *.jar sont importés par Struts mais proviennent d’autres projets.
C’est ainsi le cas de la librairie : struts-jsf-plugin.jar qui est un plug-in jsf pour Struts.
Au déploiement de l’application les archives nécessaires sont copiées dans le répertoire
WEB-INF/lib.

4. Présentation de JavaServerFaces (JSF)
a) Présentation générale
JavaServerFaces est paru en 2004 après Struts. JSF a été réalisé par Sun pour J2EE
1
.
L’adresse officielle de JavaServerFaces est :
http://java.sun.com/javaee/javaserverfaces/
Beaucoup crurent que l’arrivée de JSF allait écraser son concurrent. En effet, bien intégré
aux projets de Sun tels que Java Enterprise Edition (Java EE), JSF a su s’imposer par sa
simplicité. La partie Vue de JSF a été bien pensée et est très simple d’utilisation. Ainsi son
utilisation s’impose pour les projets de petites tailles.
b) Principes de mise en œuvre de JavaServerFaces
Une application basique de JSF est constituée de deux dossiers : l’un contient la partie
modèle de l’application. Tandis que l’autre contient la partie Vue de l’application ainsi qu’un
dossier WEB-INF qui constitue le contrôleur. De manière à permettre aux développeurs web
de se concentrer uniquement sur leurs besoins, JSF utilise XML ou des propriétés. Les pages
jsp (java server pages) utilisent des balises personnalisées JSF :
Exemples : <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
La structure de l’application web doit être décrite dans un fichier: faces-config.xml. Ce
fichier contient toutes les règles de navigations nécessaires à l’application.
Exemple :
<navigation-rule>
<description>
The decision rules used by the NavigationHandler to determine which view must be
displayed after the current view, response.jsp is processed.
</description>
<from-view-id>/response.jsp</from-view-id>
<navigation-case>
<description>
Indicates to the NavigationHandler that the greeting.jsp view must be displayed if
the Action referenced by a UICommand component on the response.jsp view returns the
outcome "success".
</description>
<from-outcome>success</from-outcome>
<to-view-id>/greeting.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Dans cet exemple on voit que l’action « success » permet de passer de la page
response.jsp à la page greeting.jsp
1
Nous parlerons ici de l’implémentation de référence de Sun mais il faut savoir qu’il
existe une autre implémentation de ce framework : Apache MyFaces qui fait parti du projet
Jakarta.