Struts 2 - Le framework de développement d'applications Java EE - Présentation

Il existe en programmation deux types d'individus :

• Les programmeurs système
• Les programmeurs d'applications

Les programmeurs système écrivent le code qui sera utilisé par les programmeurs d'applications. Les programmeurs système développent les langages Java, PHP, C ou encore C++ et les programmeurs d'applications utilisent ces langages et outils pour créer de la valeur ajoutée à des fins commerciales. Les programmeurs d'applications se concentrent sur leurs projets sans se soucier des techniques et mécaniques de bas niveaux. Les programmeurs d'applications utilisent des bibliothèques ou outils appelés : framework.

Un framework est un ensemble de bibliothèques, d'outils et de règles à suivre, qui aident au développement d'applications. Les frameworks sont développés par des programmeurs système. Un framework est composé de plusieurs briques/composants qui sont en interaction les uns avec les autres. Les applications peuvent être écrites de manière plus efficace si nous utilisons un framework adapté au projet au lieu d'être obligé de réinventer à chaque fois la roue. Un framework Java fournit un ensemble de fonctionnalités à partir d'une implémentation objet. Lors de développement à grande échelle et de conception par équipe, les frameworks sont alors très utiles, voire indispensables.

Actuellement, différents types de frameworks sont disponibles :

• Les frameworks d'infrastructure système, qui permettent de développer des systèmes d'exploitation, des outils graphiques et des plates-formes Web (Struts, Spring...)
• Les frameworks communicants (appelés intergiciels)
• Les frameworks d'entreprise (développements spécifiques)
• Les frameworks de gestion de contenu (type CMS)

Les frameworks permettent la réutilisation de code, la standardisation du développement et l'utilisation du cycle de développement de type itératif-incrémental (spécification, codage, maintenance et évolution). On parle également parfois de progiciel évolué lorsque l'on désigne un framework et son cycle de vie. Actuellement, il existe beaucoup de frameworks dans tous les domaines d'application et avec pratiquement tous les langages. Voici une liste non exhaustive des frameworks utilisés en Java :

• Apache Struts
• WebWork
• JSF (Java Server Faces)
• Spring
• Wicket

Les Servlets ont été définies en 1998 et deux ans après, de grandes entreprises avaient déjà misé sur Java pour leurs applications Web. Pendant plusieurs années, ces entreprises ont développé leurs projets de façon autonome sans standard. Aujourd'hui, toutes ces sociétés mesurent l'importance des frameworks. Le choix du framework de développement est stratégique pour une entreprise, il sera déterminant pour la qualité, la productivité et la pérennité des projets.

II-1. Normes et standards▲

II-2. Framework et développement Web▲

Il existe plusieurs types d'outils pour le développement d'applications. Un framework de type ''maison'', c'est-à-dire développé par l'entreprise, n'est pas la meilleure solution. Dès les premières années de Java, les équipes d'informaticiens ont inventé leurs propres outils pour le développement et de grandes entreprises ont parfois construit leur propre framework. Ces développements sont à éviter, car aucune entreprise ne pourra consacrer suffisamment d'efforts nécessaires pour la maintenance et l'évolution du framework. De plus, les frameworks OpenSource deviennent des standards et sont testés, validés à une échelle mondiale par l'intermédiaire des projets réalisés.

Les frameworks d'éditeur présentent un risque pour les entreprises d'un point de vue développement. En effet, ils possèdent toujours un objectif caché qui est la fidélisation de l'entreprise sur les outils de l'éditeur.

Les frameworks OpenSource sont actuellement les plus nombreux et les plus aboutis. Nous retrouvons ici la qualité du travail et la même dynamique que le projet Apache. Une bonne part des projets de frameworks est d'ailleurs issue du consortium Apache. Les frameworks sont des outils complexes quelle que soit la qualité de développement et l'origine des projets. Il n'est pas nécessaire de maîtriser tous les frameworks existants, mais ceux-ci doivent être utilisés correctement. Une fois le framework choisi, il est alors nécessaire de se former et de constituer une cellule d'assistance aux équipes de développement.

Le développement Internet basé sur la technologie Java a été submergé par des API et outils de toutes sortes. Le choix d'un framework est basé sur différents critères :

• Est-ce que nous devons tout concevoir de A à Z ?
• Est-ce que le développement permet l'utilisation d'une application précédemment développée ou une partie ?
• Est-ce que nous pouvons utiliser un environnement comme fondement de l'application ?

La conception de A à Z permet de parfaitement maîtriser une technologie mais nécessite beaucoup de temps et d'argent. Le développement à partir d'applications existantes est intéressant uniquement si les développeurs des projets antérieurs sont présents. La troisième approche (utiliser un environnement comme fondement de l'application) est sans aucun doute la meilleure dans la plupart des cas.

Les technologies Servlets et JavaServer Pages (JSP) sont le socle de base du développement Java EE. Le problème avec ces technologies est la quantité de code à développer pour les communications HTML/JSP, Servlets et Modèles. De même, sans l'utilisation d'un modèle de conception de type Modèle Vue Contrôleur MVC, le mélange de scripts HTML, SQL et Java est une mauvaise idée. Le débogage est alors plus complexe et plus long à réaliser. Le mélange de code empêche la réutilisation et visibilité des structures de contrôle. Affichage et accès aux données étant confondus.

Enfin, l'utilisation d'objets JavaBeans et de gestionnaires de balises comme Java Standard Tag Library (JSTL) permet un développement simple et consistant, même pour des projets complexes. L'écriture de code HTML/XHTML dans des pages JSP est très rapide pour le développeur. En effet, les JSP ne remplacent pas les Servlets mais sont largement complémentaires.

Avec un modèle de site très simple entièrement réalisé en JSP, les pages sont compilées et transformées en Servlets. C'est le modèle le plus utilisé par les programmeurs débutants car il est simple et rapide à mettre en œuvre.

Avec un modèle de conception un peu plus complexe, les développeurs utilisent les Servlets pour les traitements, et les pages JSP pour l'affichage. Ce modèle est plus difficile à mettre en œuvre mais il est plus naturel et offre une meilleure maintenance.

Enfin, pour une architecture multi-niveaux de type MVC, les Servlets représentent l'aspect Contrôle, les Modèles l'accès aux données et les JSP la partie Vue. Ce modèle est plus complexe à développer mais beaucoup plus simple à tester, à maintenir et faire évoluer. De même, la notion de réutilisabilité est mise en avant avec ce type de modèle.

Le projet OpenSource Jakarta-Struts développé par le consortium Apache permet d'accélérer le développement d'applications Internet. Struts 1 est quasiment devenu le standard de fait pour les projets Java EE. Struts 1 est un environnement agréable et puissant qui gère l'application ainsi que les tâches courantes (routage, actions, validations...). Un autre avantage de son utilisation est le nombre croissant d'utilisateurs qui tendent à pérenniser le projet. Actuellement beaucoup d'environnements de développement comme Eclipse proposent des outils pour la programmation Struts 1.
Struts 1 est un framework qui offre des outils de validation des entrées utilisateurs (saisies et formulaires), des bibliothèques de balises JSP pour la création rapide de pages, une technique de routage pour les pages et accès web et un processus de création de formulaires à base de fichiers XML. Struts 1 offre également d'autres avantages :

• Struts 1 fonctionne avec tous les serveurs Java EE (Tomcat, WebSphere, Weblogic...)
• Struts 1 propose une architecture solide et stable (projet Apache)
• Struts 1 est adapté aux applications web de grande taille
• Struts 1 permet de décomposer une application complexe en composants plus simples
• Struts 1 garantit un développement similaire par les équipes de programmeurs
• Struts 1 possède une documentation abondante
• Struts 1 permet un développement rapide et peu onéreux

Le terme Struts fait référence aux piliers ou étais, dans le sens architectural du terme, avec la notion de morceaux ou briques qui soutiennent des bâtiments, des maisons et des ponts afin d'éviter qu'ils ne deviennent des ruines.

Comme nous venons de le préciser dans l'introduction, le modèle de conception de type MVC est actuellement préconisé pour le développement d'applications web évoluées. Cependant, les principaux inconvénients de ce type de conception sont :

• La difficulté à comprendre le modèle et le niveau d'expertise que cela requiert
• Le nombre de fichiers à produire (environ trois fois plus)
• L'aspect rébarbatif des tâches à réaliser

La question est alors de savoir comment diminuer ces inconvénients et augmenter la productivité ?

Craig R. McClanahan's décide peu avant 2000 de créer un outil de conception de type framework pour accélérer les développement Java EE. Il fait ensuite don à la fondation Apache en mai 2000 de son framework nommé Struts 1.0 et sa première sortie est programmée pour juin 2001. Il devient alors le framework de conception Java EE le plus populaire du monde.

A peu près à la même période, plusieurs développeurs travaillent à la création d'un autre framework de développement nommé WebWork. Ce framework n'aura jamais la popularité de Struts mais reste supérieur sur plusieurs points, notamment la mise en place de validations de formulaires et l'architecture globale pour la gestion des JavaBeans (pas besoin d'utiliser des Beans de formulaires). Un point important de WebWork par rapport à Struts 1.X est la notion de tests. Avec Struts 1.X un navigateur web est nécessaire pour réaliser une partie des tests mais WebWork peut fonctionner sans.

Fin 2005, le produit WebWork et le framework le plus populaire Struts 1.0 fusionnent pour fonder Struts TI (Titanium) qui devient rapidement Struts 2.0. Les concepteurs de Struts 1.0 et Jason Carreira's responsable de WebWork, proposent alors un framework regroupant les avantages des deux précédents outils (WebWork et Struts 1.0). Cependant, Struts 2 n'est pas une extension de Struts 1 et cela peut malheureusement, décevoir plusieurs développeurs et architectes web car ce nouveau framework est une refonte complète. Les spécialistes devront ainsi réapprendre en intégralité les commandes et fonctionnalités de Struts 2.0. La refonte correspond en effet plus à WebWork version 2.2 (WebWork étant lui-même basé sur XWork d'Open Symphony) qu'à une évolution de Struts 1.0.

Le framework Struts 2 repose sur une déclaration de l'architecture sous forme de fichiers XML ou avec des annotations Java localisées dans les fichiers des classes d'actions. Struts 2 est un framework orienté actions. Les actions sont décomposées en trois rôles. Premièrement, les actions jouent le rôle le plus important du framework en encapsulant le traitement et le travail à réaliser par le service. Deuxièmement, les actions permettent de manipuler automatiquement les données des requêtes lors des transferts. Troisièmement, le framework détermine quel résultat doit être retourné et la vue à afficher en réponse à un traitement. Les actions Struts 2 implémentent des objets JavaBeans (classes Java simples) pour chaque groupe de données envoyées dans la requête. Chaque paramètre de la requête est déclaré dans la classe d'action avec un nom identique pour réaliser automatiquement le mapping des valeurs. La finalité d'une action étant de retourner une chaîne de caractères permettant de sélectionner le résultat à afficher.

Pour résumer, Struts 2 repose donc sur le modèle de conception de type MVC II comme il est expliqué dans le schéma suivant. Il permet un développement plus rapide, plus souple et résout plusieurs problèmes de conception en fournissant les services suivants :

• Un système évolué de gestion du routage ou navigation
• Un système de validation de formulaires et d'entrées, simple à mettre en oeuvre
• Un système puissant de plug-ins ou d'extensions (pour les graphiques, sources de données...)
• La gestion de l'internationalisation pour le développement de sites multilingues
• Le support de la technologie Ajax
• Un outil de débogage en standard
• Une bibliothèque puissante de balises

Struts 2 propose (tout comme Struts 1 d'ailleurs) d'utiliser un minimum de règles de conceptions qui ne sont malgré tout pas obligatoires :

• Ne pas utiliser de code 100% Java dans les pages JSP. Toute la logique de contrôle étant placée dans les classes d'actions (Servlets)
• Utiliser des bibliothèques de balises pour accéder aux objets et parcourir des collections
• Écrire le minimum de code répétitif et utiliser les outils proposés par le framework

Ce framework est ainsi conçu pour aider les développeurs d'applications web en Java à créer des projets de qualité selon une norme ou standard. Ce framework aide également les développeurs à organiser la logique de l'application.

Le choix du framework Struts 2 repose sur les points suivants :

• Fiabilité : Le projet est développé et suivi depuis mai 2000. Ce projet jouit d'une excellente réputation et améliore sans cesse ses défauts
• Flexibilité : Chaque action peut être personnalisée, les fichiers de configuration sont très souples en terme d'utilisation et les validations sont simples à mettre en oeuvre
• Performance : L'architecture conçue par Struts 2 repose sur WebWork. Elle est particulièrement performante et maintenable grâce à la séparation par couche

Les principales caractéristiques du framework Struts 2 sont les suivantes :

• Les types de conversions automatiques pour les collections issues des requêtes HTTP
• Les fichiers de configuration modulables utilisés par paquetages
• Les annotations Java 5 qui réduisent les lignes de code pour la configuration
• L'utilisation de tags permet d'appliquer des thèmes ou modèles (templates)
• L'utilisation du langage d'expression, OGNL
• La mise en place optionnelle du plug-in intercepteur (interceptr) permettant d'exécuter des requêtes complexes et longues en tâche de fond avec la soumission multiple (rafraîchissement de pages)
• L'intégration simple d'outils comme JSTL, Spring ou Hibernate

Le framework Struts 2 est une seconde génération de framework MVC. Le principal avantage de la notion d'intercepteurs est la flexibilité de l'ensemble et la configuration proposée. Struts 2 repose également sur le principe d'empaquetage des actions. Lorsque nous déclarons des classes d'action avec un fichier XML ou des annotations Java, le framework organise tous ces composants sous la forme d'une logique de paquetage (packages). Les paquetages Struts 2 sont similaires aux paquetages Java. Ce mécanisme permet également de grouper les actions par domaine. Les URLs de l'application sont alors associées à des paquetages où chaque action est déclarée.

Le framework Struts 2 est basé sur Java EE 5 (Servlets 2.4 et JSP 2.0 minimum). Pour utiliser les exemples du livre, nous utilisons les dernières versions des outils avec le JDK 1.6, Tomcat 6.X, les Servlets 2.5, Struts 2.1.6 et Eclipse/Lomboz 3.4. Le site officiel de Struts 2 est accessible à cette adresse : http://struts.apache.org/2.x/

L'installation de l'API est simple, il suffit de copier les fichiers téléchargés dans les répertoires d'une application web Java EE traditionnelle. Nous pourrons créer un nouveau projet et copier les fichiers nécessaires (librairies .jar) ou alors installer le framework en utilisant une application Struts vierge livrée avec le framework (http://apache.cict.fr/struts/examples/struts-2.1.6-apps.zip).

Il existe plusieurs versions de projets pour installer Struts 2. Dans la partie Download du site, nous retrouvons les dernières versions de Struts avec des archives au format .zip. Les versions struts-version-all.zip incluent toutes les librairies, les fichiers sources et des exemples de mise en application. La version utilisée dans ce guide est struts-2.1.6-all.zip de 90 Mo. La version struts-version-lib.zip contient uniquement les librairies au format .jar nécessaires à la mise en place de Struts 2.

Le framework Struts V2 est composé de plusieurs fichiers. Les librairies Java (.jar) contiennent toutes les classes utilisées par le framework :

• commons-fileupload.jar (librairie de gestion de l'upload en Java).
• commons-logging.jar (librairie de loggin/traces).
• commons-io-version.jar (librairie de gestion des entrées/sorties).
• freemarker-version.jar (librairie utilisée pour la mise en page et le moteur de templates).
• ognl-version.jar (librairie utilisée pour la manipulation d'objets Java).
• junit-version.jar (librairie du framework de gestion des tests unitaires).
• struts2-core-version.jar (librairie complète Struts 2, c'est la bibliothèque principale).
• xwork-version.jar (librairie de XWork avec les dépendances).

La bibliothèque native du framework est struts2-core-version.jar tandis que les librairies commons, sont fournies par la fondation Apache et le projet Commons project.

Il existe deux façons d'installer le framework Struts :

• Copier les librairies .jar dans le répertoire /WEB-INF/lib d'une nouvelle application
• Utiliser une application Struts vide, livrée en standard permettant d'installer le framework. Cette application vide porte le nom de struts2-blank-version.war pour indiquer qu'elle est vierge

Pour installer cette application, il est nécessaire de :

• Copier l'archive struts-blank-version.war dans un répertoire (ex : installationstruts2)
• Décompresser son contenu
• Ouvrir Eclipse et cliquer sur Fichier - Nouveau - Projet - Java - Projet Tomcat ou Projet web
• Nommer le projet (ex : installationstruts2) et sélectionner le répertoire précédent

• Éditer le projet et renommer les paquetages sans le terme java
• L'arborescence du projet doit alors être la suivante :

• Démarrer Tomcat et ouvrir un navigateur
• Saisir l'URL suivante dans le navigateur : http://localhost:8080/installationstruts2/

Nous pouvons également tester l'application d'authentification fournie en standard : http://localhost:8080/installationstruts2/example/Login.action

Ce chapitre a présenté le principe d'un framework et l'intérêt de l'utilisation d'un tel outil pour les développements web.
La seconde partie introduit les différents framewoks et apporte des pistes de réflexion pour le choix d'un framework. La partie suivante est un rappel des services proposés par le framework Struts 1 tandis que le nouvel outil Struts 2 est présenté ainsi que son installation et la mise en place d'un premier exemple vierge.