Nicolas CHAPON Valtech Technology

Facilitez vos dveloppements J2EE avec JBoss Seam

Octobre 07

Rsum
Le framework JBoss Seam est actuellement un des frameworks de la communaut Java qui gnre le plus de buzz . Pour certains, Seam est encore un framework parmi tant dautres et, pour dautres, cest la solution technique ultime pour le dveloppement dapplications web sur JEE5. A premire vue, JBoss Seam fait plutt penser une sorte de vitrine technologique du savoir faire de la communaut JBoss (Hibernate, JBPM, Drools, JBoss Cache, RichFaces, JBoss Ejb3 ). Mais quand on y regarde de plus prs, le framework JBoss Seam permet rellement de faciliter et daugmenter la productivit des dveloppements web bass sur JEE5 grce notamment certains concepts novateurs (modle de composant unifi) et aussi aux amliorations apportes JEE5. Seam nous rconcilie avec la technologie J2EE et surtout avec les dveloppements JSF, il est donc tout fait possible dutiliser Seam en dehors du contexte JEE5.

Table des matires

1. SEAM : LE FRAMEWORK D'INTEGRATION JEE5___________________________________4
1.1 1.2 1.3 Pourquoi choisir Seam ? ......................................................................................................... 4 Historique ................................................................................................................................ 4 Concepts techniques............................................................................................................... 4
Le modle de composant Seam .................................................................................................... 4 Contextes Seam ............................................................................................................................ 6 Injection des dpendances ............................................................................................................ 7 Gestion des conversations............................................................................................................. 7 Intgration avec JPA...................................................................................................................... 8 Simplification de JSF ..................................................................................................................... 9 Support Web 2.0 ............................................................................................................................ 9

1.3.1 1.3.2 1.3.3 1.3.4 1.3.5 1.3.6 1.3.7

1.4

Utilisation de Seam en dehors de JEE5................................................................................ 10

2. CONCLUSION __________________________________________________________10

Liste des Figures

Figure 1: Intgration JSF/EJB 3 sans le framework Seam................................................................................................... 5

1. Seam : le framework d'intgration JEE5

1.1 Pourquoi choisir Seam ?
Le dveloppement d' applications web bases sur J2EE se rsume souvent assembler un ou plusieurs frameworks, parfois pour chaque couche applicative, ces frameworks tant bass ou non sur des standards et bien souvent en provenance de la communaut open source (Struts, JSF, Spring, Hibernate, iBATIS, Axis 2, Dozer ...). Il n' pas rare de se retrouver avec une dizaine de composants techniques intgrer avec chacun est leur propre modle de dveloppement, leur propre mcanisme de configuration et les ventuelles problmatiques de compatibilit. Par exemple le choix des librairies JSF demande actuellement pas mal de rflexion ! Avec le framework JBoss Seam, plus besoin de se poser de questions sur le choix des composants techniques intgrer ; Seam est livr avec tous les composants ncessaires au dveloppement d' une application web et, en plus, il permet de simplifier grandement les dveloppements grce son modle de composants unifi.

1.2

Historique

Le framework JBoss Seam est un framework Open Source l' initiative de Gavin King (fondateur du framework Hibernate). A l' origine, le but de Seam tait de permettre l' implmentation d' applications web stateful partir de JSF 1.2 et des EJB3 (principaux concepts de JEE5), tout en s' affranchissant des problmatiques lies au framework Hibernate. Et comme JEE5 ne permet pas de couvrir tous les besoins techniques d' une application web, le framework Seam propose une extension de JEE5 avec des concepts novateurs et intgre galement d' autres frameworks en provenance de la communaut Open Source. Au final Seam est devenu un veritable framework d' intgration de JEE5 la manire de Spring pour J2EE 1.4. La version 1.0 de Seam est sortie en Juin 2006, la version 1.2.1 GA est la dernire version stable et la version 2.0 est attendue avant la fin 2007.

1.3
1.3.1

Concepts techniques
Le modle de composant Seam

A l' origine le modle de composants de Seam a t conu pour permettre l' intgration directe entre JSF et les EJB3. Quand on dveloppe une application web partir de JSF, on implmente gnralement deux types de composants :

une page JSF qui va constituer la vue et contenir le code HTML, une classe Java appele backing bean JSF qui va constituer le modle et fournir les mthodes pour implmenter les actions utilisateurs (soumission formulaire ...)

Les mthodes du backing bean JSF lies aux actions utilisateurs accdent en gnral un composant mtier. Si celui-ci est dploy sous la forme d' EJB 3 de type Session Bean, il est un alors ncessaire d' implmenter une couche d' adaptation entre ces deux types de composants.

Figure 1: Intgration JSF/EJB 3 sans le framework Seam

Avec Seam, il n' a plus de distinction entre le composant backing bean et le composant mtier ; ils y forment un seul et unique composant qu' appelle composant Seam. Une page JSF peut donc on invoquer directement un composant mtier dploy sous la forme d' Session Bean. un

Figure 2: Intgration JSF/EJB3 avec le framework Seam

Un composant Seam est une classe java du type POJO ou EJB 3.0 qui contient l' annotation @name. Exemple : dclaration d' composant Seam du type EJB3 Session Bean Stateful : un
@Stateful @Name("manager") public class ManagerAction { }

Chaque composant Seam est dclar sous un nom logique (ici manager) et l' appel de ce composant depuis une page JSF s' effectue de la faon suivante :

Avec ce principe les dveloppements JSF sont simplifis, puisque il n' a plus besoin de dclarer y les backing beans dans le fichier de configuration faces-config.xml. La spcification Web Beans JSR 299 (http://jcp.org/en/jsr/detail?id=299) est base sur les concepts de ce modle de composant et sera trs certainement intgre dans la spcification JEE6. 1.3.2 Contextes Seam

On accde un composant Seam depuis son contexte. Chaque type de composant est dclar par dfaut dans un contexte mais il est facile d' tendre le contexte d' composant. Pour cela, Seam un met notre disposition diffrents contextes :

stateless qui est le contexte par dfaut des composants EJB Stateless, request (idem J2EE correspond la requte HTTP) ou event qui est le contexte par dfaut des composants du type POJO ou JavaBean, page (idem J2EE), le composant est accessible sur la dure de vie d' page JSF, une conversation qui est le contexte par dfaut des composants du type EJB Stateful, session (idem J2EE), le composant est accessible depuis la session HTTP, process, contexte utilis pour la gestion des processus (par exemple JBPM) application (idem J2EE).

Figure 3: Les contextes Seam

La dclaration du contexte s' effectue partir de l' annotation Java 5 @scope. Dans l' exemple ci dessous le JavaBean myBean est dclar dans le contexte de conversation :

9 8 7 ! ! & % 

& 6  5 &  3 2   0  % ! $% 4" &1) !( '$ &$#!  ! %  "

      

@Name("myBean") @Scope(ScopeType.CONVERSATION) public class MyBean { }

1.3.3

Injection des dpendances

Pour que les composants puissent interagir entre eux, Seam propose un mcanisme d' injection des dpendances bijectif :

un composant peut tre inject automatiquement dans un autre composant (quivalent au mcanisme d' injection des dpendances du framework Spring), un composant peut galement crer et projeter un autre composant dans un contexte (outjection) qui deviendra ainsi accessible par tous les autres composants.

L' injection ou la projection des dpendances s' effectue encore une fois partir d' annotations Java, respectivement @In et @Out. Exemple :
@Name("myBean") public class MyBean { //Composant inject par seam @In private ComponentA componentA; // Composant projet par Seam // dans le contexte de Session @Out(scope=ScopeType.SESSION) private ComponentB componentB; }

Il est galement possible de forcer la cration ou non des composants au moment de l' injection. Avec Seam, nous avons donc un mcanisme d' injection des dpendances compltement dynamique, ne ncessitant pas de configuration XML. 1.3.4 Gestion des conversations

Actuellement, pour grer l' tat conversationnel dans une application web, la seule solution est de stocker les informations au niveau de la session HTTP, ce qui entrane souvent des problmes de rinitialisation ou de purge des informations. Avec Seam, on utilise ce qu' appelle les conversations longues soit de manire implicite partir on de composants du type EJB3 stateful ou bien avec des JavaBeans en les dclarant dans le contexte de conversation. Une conversation Seam va donc englober plusieurs requtes et un utilisateur pourra utiliser plusieurs conversations sachant que chaque conversation est compltement indpendante. Le dmarrage d' une conversation longue s' effectue de manire explicite en positionnant par exemple une annotation Java @Begin au niveau d' mthode mtier. une

De la mme faon une conversation est termine partir de l' annotation @End sur une mthode ou bien ds qu' tombe en timeout. elle Exemple :
@Name("myBean") @Stateful public class MyBean { // Resultats de recherche // stock en conversation @Out private List<ComponentB> results; @Begin public void search(){ results = doSearch(); } @End public void cancel(){ } private List doSearch() { //Business Code } @Destroy @Remove public void destroy() { } }

Dans l' exemple ci-dessus, Seam nous rconcilie avec les EJB Stateful pourtant si dcris dans les prcdentes versions de J2EE : l' annotation @Destroy qui, superpose l' annotation EJB3 @Remove, permet de supprimer l' EJB stateful du conteneur EJB ds que la conversation est termine ou bien en timeout. Pour rsumer, les conversations Seam permettent de dvelopper des applications web stateful trs robustes, en utilisant enfin des composants techniques prvus cet effet (EJB Stateful) au lieu des sessions HTTP. 1.3.5 Intgration avec JPA

JPA (Java Persistence API) est l' de persistance fournie par JEE5. Cette API se base en grande API partie sur les concepts apports par Hibernate, le framework incontournable de mapping relationnel objet (ORM). JPA et Hibernate ont un mcanisme de chargement des donnes la demande (Lazy Loading), pour viter par exemple qu' seul select sur une table parent rcupre toutes les donnes des un tables filles. Ce chargement des donnes la demande n' possible qu' partir d' contexte de est un persistance (ou session hibernate) et gnralement celui-ci n' plus accessible depuis une page est JSF de l' application web, ce qui peut parfois poser des problmes pour l' affichage des donnes. Pour contourner ce problme, il y a deux solutions :

implmenter une couche d' objets (DTO pour Data Transfert Object) permettant de charger les objets de persistance avec toutes les donnes ncessaires pour l' affichage, utiliser le contournement OpenSessionInView qui consiste maintenir le contexte de persistance ouvert pour chaque requte HTTP.

Ces deux solutions, si elles fonctionnent, ont leurs limites. Dans le cas des DTO, on duplique le code et, avec la deuxime solution, on maintient le contexte de persistance ouvert pour toutes les requtes HTTP et ce mcanisme ne convient pas vraiment aux applications JSF. Avec Seam, la solution est beaucoup plus simple : le contexte de persistance sera rutilis si la page web a besoin d' afficher des donnes supplmentaires. On a donc plus besoin d' implmenter de couche DTO. 1.3.6 Simplification de JSF

Dvelopper des applications web avec JSF ncessite une bonne connaissance du mode de fonctionnement de l' API et surtout des moyens de contournements permettant de combler les lacunes actuelles de cette API. Pour cela, Seam tend certaines phases du cycle de vie JSF de faon pouvoir : garder les donnes en request mme aprs un redirect, grer simplement les vnements utilisateurs sur un tableau de donnes partir des composants DataModel, amliorer la gestion des erreurs qui se dclenchent lors d' phase du cycle de vie JSF, une enrichir le mcanisme de validation JSF partir des annotations Hibernate Validator, mettre en place des pageflows robustes (possibilit de dtecter le retour arrire sur un navigateur...) ...

Il faut noter que cette extension de JSF est compatible avec la plupart des implmentations open source JSF 1.1 ou 1.2 (Sun, MyFaces, IceFaces, RichFaces...). D' autre part, Seam fournit galement une bibliothque de tags JSF (Seam Controls) qui tend l' API JSF de rfrence. Cette extension permet notamment de dvelopper des applications web du type ReStFull (c' dire accessible en GET HTTP). Il faut savoir que, par dfaut, une application web est base sur JSF utilise abusivement des requtes HTTP en mode POST, il est donc par exemple trs difficile de mettre un lien sur certaines pages d' telle application. une 1.3.7 Support Web 2.0

Le dveloppement d' applications web 2.0 dites riches passe par l' utilisation massive de code Javascript embarqu sur le client (technologies Ajax). Actuellement, force est de constater qu' y a il plthore de solutions techniques, plus ou moins exotiques, pour mettre en oeuvre ce type de technologie... Seam nous simplifie la vie encore une fois, puisqu' est livr avec des librairies capables il d' implmenter des applications Web 2.0 : la librairie Ajax4JSF permet d' embarquer des technologies Ajax au niveau des composants JSF,

le mcanisme de Seam Remoting permet du code Javascript cot client d' invoquer de manire asynchrone un composant Seam Java dploy cot serveur, enfin Seam est compatible avec les librairies JSF RichFaces et IceFaces, deux librairies JSF open source permettant le dveloppement d' applications web 2.0.

1.4

Utilisation de Seam en dehors de JEE5

JEE5 se diffusant encore trop lentement, les concepteurs de Seam ont donc prvu de pouvoir utiliser Seam en dehors de JEE5 condition d' utiliser Java 5. Une architecture possible est d' intgrer Seam avec le framework Spring :

Figure 4: Architecture Seam avec Spring

Dans ce type d' architecture, Seam est utilis avant tout pour simplifier les dveloppements JSF, ce qui parfois dans le cas d' applications web complexes peut tre un choix trs intressant et facilitera plus tard la migration vers JEE5. Encore une fois, Seam nous facilite la tche en s' intgrant parfaitement avec le framework Spring : chaque bean Spring peut tre dclar comme composant Seam et donc tre inject dans un autre composant Seam avec l' annotation @In, il est possible de partager des composants entre Seam et Spring, utile par exemple pour la gestion de la persistance.

De plus, avec la version 2.0 de Seam, l' intgration avec Spring sera encore amliore (possibilit de piloter des transactions dclares au niveau de Spring...)

2. Conclusion
Seam met notre disposition un modle de composants ouvert qui va bientt devenir un standard (JSR 299), toutes les amliorations et extensions apportes par Seam permettant de simplifier les dveloppements avec JEE5. Dautre part, dans sa version actuelle, Seam couvre la plupart des besoins techniques et fonctionnels lis au dveloppement d' une application web ce qui permet dviter les habituelles questions sur le choix des composants intgrer

10

Dans cette prsentation nous navons abord que les grands concepts mais Seam fournit galement de nombreuses autres fonctionnalits :

gestion de processus mtiers et des pageflows web avec JBPM, gestion des vnements au niveau des composants, gestion des rgles mtiers avec Drools, gnralisation de l' Expression Language (EL) pour le code Java et les fichiers de configuration, support PDF, internationalisation, gestion des thmes, gestion de la scurit et des autorisations, support CRUD, tests unitaires avec TestNG, gnration de code avec l' outil seam gen (ressemble au scaffold de Ruby On Rails).

En ce qui concerne l' avenir : la version 2.0 de Seam (sortie prvue avant fin 2007) va apporter encore plus de fonctionnalits et plus de simplifications (support GWT, Hibernate Search), le prochain IDE Red Hat Studio Developper bas sur Eclipse (en versions beta actuellement http://www.redhat.com/developers/rhds/) semble trs prometteur et devrait permettre d' avoir une plate-forme de dveloppement compltement intgre avec Seam (gnration de code, wizards...).

Avec tous ces atouts, le framework Seam semble bien plac pour devenir le framework incontournable pour le dveloppement d' applications JEE5 et risque mme d' pousser dautres en vers la porte de sortie (Spring...).

11