Facilitez vos développements J2EE avec JBoss Seam

À l'origine, le modèle de composants de Seam a été conçu pour permettre l'intégration directe entre JSF et les EJB3.

Quand on développe une application web à partir de JSF, on implémente généralement deux types de composants :

• une page JSF qui va constituer la vue et contenir le code HTML ;
• une classe Java appelée backing bean JSF qui va constituer le modèle et fournir les méthodes pour implémenter les actions utilisateur (soumission formulaire ...).

Les méthodes du backing bean JSF liées aux actions utilisateurs accèdent en général à un composant métier. Si celui-ci est déployé sous la forme d'un EJB 3 de type Session Bean, il est alors nécessaire d'implémenter une couche d'adaptation entre ces deux types de composants.

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

Un composant Seam est une classe Java du type POJO ou EJB 3.0 qui contient l'annotation @name.

Exemple : déclaration d'un composant Seam du type EJB3 Session Bean Stateful :

@Stateful
@Name("manager")
public class ManagerAction {
}

Chaque composant Seam est déclaré sous un nom logique (ici manager) et l'appel de ce composant depuis une page JSF s'effectue de la façon suivante :

<h:commandButton id="save" action="#{manager.save}" value="Save" />

Avec ce principe, les développements JSF sont simplifiés, puisque il n'y a plus besoin de déclarer les backing beans dans le fichier de configuration faces-config.xml.

La spécification Web Beans JSR 299 (http://jcp.org/en/jsr/detail?id=299) est basée sur les concepts de ce modèle de composant et sera très certainement intégrée dans la spécification JEE6.

On accède à un composant Seam depuis son contexte. Chaque type de composant est déclaré par défaut dans un contexte, mais il est facile d'étendre le contexte d'un composant. Pour cela, Seam met à notre disposition différents contextes :

• stateless qui est le contexte par défaut des composants EJB Stateless ;
• request (idem J2EE correspond à la requête HTTP) ou event qui est le contexte par défaut des composants du type POJO ou JavaBean ;
• page (idem J2EE), le composant est accessible sur la durée de vie d'une page JSF ;
• conversation qui est le contexte par défaut 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).

La déclaration du contexte s'effectue à partir de l'annotation Java 5 @scope. Dans l'exemple ci-dessous, le JavaBean myBean est déclaré dans le contexte de conversation :

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

Pour que les composants puissent interagir entre eux, Seam propose un mécanisme d'injection des dépendances bijectif :

• un composant peut être injecté automatiquement dans un autre composant (équivalent au mécanisme d'injection des dépendances du framework Spring) ;
• un composant peut également créer et projeter un autre composant dans un contexte (outjection) qui deviendra ainsi accessible par tous les autres composants.

L'injection ou la projection des dépendances 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 création ou non des composants au moment de l'injection.

Avec Seam, nous avons donc un mécanisme d'injection des dépendances complètement dynamique, ne nécessitant pas de configuration XML.

Actuellement, pour gérer l'état conversationnel dans une application web, la seule solution est de stocker les informations au niveau de la session HTTP, ce qui entraîne souvent des problèmes de réinitialisation ou de purge des informations.

Avec Seam, on utilise ce qu'on appelle les conversations longues soit de manière implicite à partir de composants du type EJB3 stateful ou bien avec des JavaBeans en les déclarant dans le contexte de conversation.

Une conversation Seam va donc englober plusieurs requêtes et un utilisateur pourra utiliser plusieurs conversations sachant que chaque conversation est complètement indépendante.

Le démarrage d'une conversation longue s'effectue de manière explicite en positionnant par exemple une annotation Java @Begin au niveau d'une méthode métier.

De la même façon, une conversation est terminée à partir de l'annotation @End sur une méthode ou bien dès qu'elle tombe en timeout.

Exemple :

@Name("myBean")
@Stateful
public class MyBean {

    // Résultats de recherche
    // stockés 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 réconcilie avec les EJB Stateful pourtant si décriés dans les précédentes versions de J2EE : l'annotation @Destroy qui, superposée à l'annotation EJB3 @Remove, permet de supprimer l'EJB stateful du conteneur EJB dès que la conversation est terminée ou bien en timeout.

Pour résumer, les conversations Seam permettent de développer des applications web stateful très robustes, en utilisant enfin des composants techniques prévus à cet effet (EJB Stateful) au lieu des sessions HTTP.

JPA (Java Persistence API) est l'API de persistance fournie par JEE5. Cette API se base en grande partie sur les concepts apportés par Hibernate, le framework incontournable de mapping relationnel objet (ORM).

JPA et Hibernate ont un mécanisme de chargement des données à la demande (Lazy Loading), pour éviter par exemple qu'un seul select sur une table parent ne récupère toutes les données des tables filles. Ce chargement des données à la demande n'est possible qu'à partir d'un contexte de persistance (ou session hibernate) et généralement celui-ci n'est plus accessible depuis une page JSF de l'application web, ce qui peut parfois poser des problèmes pour l'affichage des données.

Pour contourner ce problème, il y a deux solutions :

• implémenter une couche d'objets (DTO pour Data Transfert Object) permettant de charger les objets de persistance avec toutes les données nécessaires pour l'affichage ;
• utiliser le contournement OpenSessionInView qui consiste à maintenir le contexte de persistance ouvert pour chaque requête HTTP.

Ces deux solutions, si elles fonctionnent, ont leurs limites. Dans le cas des DTO, on duplique le code et, avec la deuxième solution, on maintient le contexte de persistance ouvert pour toutes les requêtes HTTP et ce mécanisme ne convient pas vraiment aux applications JSF.

Avec Seam, la solution est beaucoup plus simple : le contexte de persistance sera réutilisé si la page web a besoin d'afficher des données supplémentaires. On n'a donc plus besoin d'implémenter de couche DTO.

Développer des applications web avec JSF nécessite 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 façon à pouvoir :

• garder les données en request même après un redirect ;
• gérer simplement les événements utilisateur sur un tableau de données à partir des composants DataModel ;
• améliorer la gestion des erreurs qui se déclenchent lors d'une phase du cycle de vie JSF ;
• enrichir le mécanisme de validation JSF à partir des annotations Hibernate Validator ;
• mettre en place des pageflows robustes (possibilité de détecter le retour arrière sur un navigateur...) ;
• ...

Il faut noter que cette extension de JSF est compatible avec la plupart des implémentations open source JSF 1.1 ou 1.2 (Sun, MyFaces, IceFaces, RichFaces...).

D'autre part, Seam fournit également une bibliothèque de tags JSF (Seam Controls) qui étend l'API JSF de référence. Cette extension permet notamment de développer des applications web du type ReStFull (c'est-à-dire accessibles en GET HTTP). Il faut savoir que, par défaut, une application web basée sur JSF utilise abusivement des requêtes HTTP en mode POST, il est donc par exemple très difficile de mettre un lien sur certaines pages d'une telle application.

Le développement 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'il y a pléthore de solutions techniques, plus ou moins exotiques, pour mettre en œuvre ce type de technologie...

Seam nous simplifie la vie encore une fois, puisqu'il est livré avec des librairies capables d'implémenter des applications Web 2.0 :

• - la librairie Ajax4JSF permet d'embarquer des technologies Ajax au niveau des composants JSF ;
• - le mécanisme de Seam Remoting permet à du code Javascript côté client d'invoquer de manière asynchrone un composant Seam Java déployé côté serveur ;
• enfin Seam est compatible avec les librairies JSF RichFaces et IceFaces, deux librairies JSF open source permettant le développement d'applications web 2.0.