Le framework Jboss Seam

15 August 2010 par bellan_d

Seam est une plateforme de développement open source permettant de concevoir des RIA (Rich Internet Application) en Java. Seam défini un modèle de composants uniforme pour l'ensemble des processus métiers de votre application.

Un composant seam peut être Stateful et être associé à l'un des contextes suivants :

  • long-running persistent  : session classique
  • business process  : les données restent en mémoire le temps du déroulement d'un processus métier
  • conversation  : les données sont conservées en mémoire le long de plusieurs requètes effectuées par les utilisateurs et effacées lorqu'on le désire (session classique bien plus affinée)

Seam ne fait pas de distinction entre la couche présentation et la couche métier. Aussi il est possible d'architecturer son application de la manière que l'on souhaite sans être forcé d'utiliser une architecture imposée ce qui est le cas dans la majorité des autres frameworks j2EE.

Contrairement aux composants J2EE classiques, les composants Seam peuvent simultanément accéder à la fois aux états associés aux requêtes web et aux états contenus dans les ressources transactionnelles sans avoir à programmer manuellement les requêtes web avec des méthodes paramétrées.

Les personnes préférant utiliser l'architecture des anciens framework J2EE peuvent toujours créer une architecture équivalente en utilisant Seam. La différence est qu'elles devront définir quelles sont les différentes couches et comment elles fonctionnent ensembles.

Les outils que fournit le framework

JSF (Java Server Facelet) intégrées avec les EJB 3.0 (Entity Java Beans):

JSF et EJB 3.0 sont deux des fonctionnalités majeures comprises dans Java EE 5.

EJB 3 est un modèle de composant pour la gestion des processus métiers coté serveur et la persistence des objets.

JSF est un modèle de composant utilisé pour mettre en place la couche présentation.

Malheureusement, aucun de ces modèles de composant n'est capable de résoudre l'ensemble des problèmes de développement par lui-même. En effet, JSF et EJB 3.0 fonctionnent bien mieux ensembles. Cependant, les spécifications de Java EE 5 ne proposent pas de solution standard pour intégrer ces deux solutions ensembles.

Fort heureusement, les créateurs de ces deux modèles ont prévu la situation et ont créé une extension standard permettant de les intégrer ensembles dans d'autres frameworks.

Seam unifie les modèles de composants de JSF et EJB 3.0 en éliminant la création de code de liaison et en permettant aux développeur de ne réfléchir que sur le code métier.

Il est possible de développer une application Seam où tout est un EJB. Au contraire, si vous le souhaitez, il est possible de ne pas en utiliser. En effet, n'importe quelle classe Java peut être un composant Seam.

AJAX intégre :

Seam supporte les toutes dernières solutions JSF open source basées sur des solutions AJAX :

  • Jboss RichFaces
  • ICEfaces

Ces solutions permettent d'ajouter les possibilités d' AJAX à votre interface utilisateur sans avoir besoin d'écrire du code Javascript.

En tant qu'alternative, Seam propose une couche Javascript intégrée permettant d'appeler un composant de manière asynchrone depuis le Javascript de la couche client sans utiliser d'actions supplémentaires.

Gestionnaire des processus métiers :

Seam propose aussi un gestionnaire transparent des processus métiers à l'aide de jBPM. Celui-ci permet d'élaborer simplement des workflows  complexes ainsi que des systèmes de collaboration et des gestionnaires de tâches.

Seam vous permet aussi de définir un pageflow de la couche présentation en utilisant le même langage que jBPM utilise pour ses définitions de processus métiers (jPDL).

JSF propose un gestionnaire d'événements très riche pour la couche présentation. Seam s'inspire de ce gestionnaire en utilisant le même mécanisme de listeners ce qui au final donne un gestionnaire d'événements uniforme dans votre application.

Bijection :

Les notions d'inversion de contrôle et d'injection de dépendances existent à la fois dans JSF, dans EJB3 et dans beaucoup d'autres conteneurs. La plupart de ces conteneurs permettent l'injection de composant qui implémentent uniquement des services stateless.

Même lorsque l'injection de composants stateful est supportée (JSF), celle-ci est peu utile car le scope des composants stateful ne peut pas être défini avec assez de précision et que des composants appartenant à des scopes larges ne peuvent être injectés dans des scopes plus étroits.

La bijection diffère de l'inversion de contrôle dans le fait qu'elle est dynamique, contextuelle et bidirectionnelle. La bijection permet la compilation automatique des composants stateful par le conteneur. Cela permet aussi au composant de manipuler facilement la valeur d'une variable contextuelle en l'assignant juste à un attribut du composant.

Gestion de l'espace de travail et de la naviguation dans plusieurs onglets du navigateur :

Les applications Seam permettent à l'utilisateur de changer d'onglet dans son navigateur comme il le souhaite. Chaque onglet est associé à une conversation isolée avec sécurité.

Une application Seam peut aussi permettre aux utilisateurs de changer de conversation au sein d'un même onglet du navigateur.

Annotations plutôt que XML :

La plupart des frameworks J2EE proposent des descripteurs de déploiement basés sur du XML pour configurer les choses qui peuvent être vraiment différentes selon les types de déploiement de l'application et pour toute autre déclaration qui ne peut pas être facilement déclarée en Java.

L'arrivée des annotations dans Java 5 changea la donne. EJB 3.0 comprend les annotations et la configuration par exception. Il s'agit d'une manière simple de déclarer les informations au conteneur d'une façon claire.

Malheureusement, JSF est toujours très dépendant des fichiers de configuration XML très verbeux. Seam étend les annotations proposées par EJB 3.0 avec un pack d'annotations pour les déclaration d'états et de contextes. Ainsi, les informations contenues dans les fichiers XML de configuration des JSF ne sont plus que les règles de navigation.

Les tests d'intégration sont simples à réaliser :

Les composants Seam qui sont des classes Java sont, par nature, testables de manière unitaire. Cependant, pour des applications complexes les tests unitaires seuls sont insuffisants. Seam propose donc une fonctionnalité intégrée au framework permettant de créer ses tests unitaires.

Il est possible de développer rapidement des tests Junit ou TestNG qui :

  • Reproduisent des interactions complètes avec un utilisateur
  • Testent l'ensemble des composants du système en ignorant les vues.

Il est possible de lancer les tests directement dans l'IDE. Seam déploiera automatiquement les composants EJB nécessaires en utilisant Jboss Embedded

Autre fonctionnalités :

Seam intègre de nombreuses autres fonctionnalités :

  • JPA et Hibernate 3 pour gérer la persistance
  • Meldware Mail pour la gestion des emails.
  • Hibernate Search et Lucene pour la recherche
  • JAAS et Jboss Rules pour la sécurité
  • Des bibliothèques de tags JSF pour les rendus en PDF
  • Générateurs de graphiques, de tableaux et de cartes
  • Web Services
  • Génération de code

Génération d'un CRUD à partir d'une base de données

Dans cette partie nous allons voir comment générer un CRUD en ligne de commande sur un système UNIX à partir d'une base de données MySQL à l'aide des outils de génération de Seam.

Pré requis:

  • MySQL 5.1
  • JDK 1.6
  • JBoss 5.0.1 (compilé pour JDK 1.6),
  • Seam 2.2
  • Mysql connector pour Java

Dans un premier temps il est nécessaire de créer une base de données dans MySQL. Ensuite placez-vous dans le répertoire d'installation de Jboss Seam :

 $ cd chemin_vers_seam;

Nous allons ensuite configurer Seam pour qu'il génère notre application à partir de notre base de données. Pour cela il faut exécuter la commande :

$ ./seam setup;

Un questionnaire apparaît dans la console. Il va falloir répondre aux questions posée. Dans un premier temps il faut indiquer le répertoire où vous souhaitez installer votre site ainsi que le chemin vers le répertoire où se situe Jboss.

Une fois cela fait il faut noter le domaine (laisser default pour la démo) puis le chemin vers Glassfish et le domaine Glassfish (laisser les paramètres par défaut car nous ne ne l'utilisons pas).

Il faut alors entrer le nom du projet. On nous demande alors si l'ont souhaite utiliser RichFaces ou ICEfaces. Nous utiliseront RichFaces qui comprend un peu moins de composants mais qui est plus fiable (certains composants d'ICEfaces sont encore buggés). Le skin RichFaces pour notre CRUD est alors demander. Nous allons choisir emerald.

Il faut ensuite préciser si l'on souhaite déployer le site en ear ou en war. Ici nous choisirons ear car cela va nous générer un site zippé qui sera pratique pour un déploiement futur. On peut alors rentrer le nom du package de base de nos classes java (com.mon_domain.mon_projet), le nom du package pour nos bean de session : com.mon_domaine.mon_projet, le nom du package pour nos bean d'entités (com.mon_projet.entity) et enfin le nom du package pour nos tests(com.mon_projet.test).

On spécifie alors le type de base de données utilisée (mysql) ainsi que le chemin vers notre connecteur MySql. Il faut ensuite rentrer le dialecte hibernate (org.hibernate.dialect.MySQLDialect) ainsi que la classe du driver JDBC (com.mysql.jdbc.Driver) et la classe JDBC procurant les données (com.mysql.jdbc.jdbc2.optional.MysqlDataSource) et enfin l'adresse jdbc de notre base (jdbc:mysql:///).

On doit alors rentrer le login puis mot de passe de la base de données. Un nom de catalogue est alors demandé (ne rien mettre).

Pour finir le questionnaire il faut spécifier qu'il existe des tables en base et qu'on ne souhaite pas recréer les tables en base à chaque redéploiement et exécuter import.sql.

Il faut ensuite exécuter :

$ ./seam create-project

Cette commande va générer un squelette vide du site. On exécute ensuite la commande suivante :

$ ./seam generate

 

Cette commande va utiliser la base de données et générer tous les fichiers nécessaires à notre CRUD. L'avant dernière étape est de lancer la commande :

$ ./seam deploy

qui va déployer le site sur le serveur Jboss. Enfin, il faut lancer le serveur :

$ cd /bin/ puis $ run.sh

Une fois le serveur lancé allez à l'adresse http://localhost:8080/mon_projet. Vous devez y voir votre CRUD. L'ensemble des entités a été généré. Il est donc intéressant d'utiliser cet outil pour n'importe quelle création de site.

Avantages

  • Création de RIA avec simplicité, sans configuration particulière et sans utilisation de Javascript (RichFaces, ICEfaces).
  • Manière simplifier d'apprendre à utiliser des EJB 3.0
  • Génération de code très simple
  • Utilisation des annotations (simplification de la configuration)
  • Gestion simplifiée de la persistance
  • Tests d'intégration inclus dans le framework
  • Open Source

Inconvénients

L'inconvénient majeur de Seam est la complexité de compréhension du framework. Il est nécessaire  de passer beaucoup de temps à lire la documentation afin de pouvoir créer quelque chose de viable. De plus, comme il s'agit d'une plateforme assez jeune, sa communauté est peu répandue. Il est donc parfois difficile de trouver des réponses à des problèmes basiques.

Un autre inconvénient de ce framework est son adaptabilité. En effet, lorsque l'on souhaite créer quelque chose qui n'est pas spécialement prévu dans le framework cela met plus de temps que si nous passions par une solution classique.

Comparaison avec d'autres framework J2EE

Dans cette section nous allons rapidement comparer Seam avec Spring et Struts afin de voir dans quel cas il vaut mieux utiliser un framework plutôt qu'un autre. Cette comparaison va se faire sous forme de liste de critère. Pour chaque critère nous allons préciser ce que le framework propose pour le vérifier.

  • Utilisation d'AJAX : Seam, Struts
  • ORM : Struts
  • JPA, Hibernate ; Spring, Seam
  • Framework de sécurité intégré : Seam (JAAS, OpenID, etc.), Spring (Spring security)
  • Form Validation : Spring (Commons Validator), Seam (Hibernate Validators), Struts
  • Tests unitaires : Spring(mock objects et unit test), Struts (unit test), Seam (JUnit, TestNG)
  • Framework de cache : Spring (ehcache), Seam (ehcache, Jboss Cache)

Conclusion

Finalement, le framework Jboss Seam propose un très grand panel de fonctionnalités et facilite grandement la configuration des projets. Le développeur n'a plus qu'à se focaliser sur le développement de la partie métier de son application. De plus, il peut être couplé avec RichFaces ou ICEfaces très simplement et permettre le développement de RIA de manière simple. Il apporte aussi de nouvelles fonctionnalités comme les conversations ou la bijection qui rendent le framework encore plus riche.

Il est tout de même important de noter que la communauté autour de ce framework n'est pas encore très développée et qu'il faut parfois s'armer de patience pour résoudre un simple problème.

Tags: , , ,

Laisser un commentaire


one + = 8