Devoxx – Jour 1 – JSF 2

Une des sessions très attendues de ce Devoxx 2009 (avec JEE6) est JSF 2.0. Beaucoup de spécificités de JSF premier du nom ont découragé de nombreux développeurs. De ce fait, JSF n’a pas très bonne réputation… Et il faut rattraper ça ! C’est en tout cas ce qui ressort des premiers slides de cette présentation avec l’accroche choc : JSF 2.0 : it is not only us, it is you too !

Car oui : JSF 2.0 annonce la couleur et souhaite faire participer la communauté. Dans cet esprit, les speakers nous présentent le topic twitter #jsf2next pour partager autour des évolutions futures de JSF, souhaitées ou non. Ils enchaînent ensuite avec un trombinoscope de toutes les personnes qui se trouvent derrière JSF 2.0 (on reconnaîtra quelques visages au passage) :

L’aspect communautaire sera rappelé tout au long de la session et on sent vraiment que JSF met le paquet pour être apprécié des développeurs. Les speakers insisteront beaucoup sur le tag JSF2.next avec des slides spécifiques pour donner quelques idées internes ou remontées par la communauté pour (déjà) améliorer JSF 2.0.

La présentation fût découpée en 3 parties : Vue, Contrôleur et Modèle (approximativement 1h pour chaque partie), ce qui nous donne ainsi un bon aperçu de tous les changements de chaque couche du MVC. Une session de BOF spéciale JSF 2.0, qui a eu lieu le soir même, apportera quelques précisions sur certaines fonctionnalités non évoquées lors de la conférence.

Vue

Premier rappel côté Vue et déjà quelques tacles à la gorge : JSP avec ses points faibles (dont certains sont assez discutables…) :

• la complexité de développer une librairie,
• l’état stateful des tags qui impose de faire des appels à release sur les objets tags pour les réinitialiser,
• l’obligation d’une phase de compilation lors du premier affichage,
• le mélange de la présentation avec la couche métier
• le fait que JSP soit orienté contenu (et non composant).

Facelets arrive ainsi avec ses XHTML tags, stateless par défaut, des librairies plus simples à développer, du templating et plus de compilation Java. Et, première bonne nouvelle pour les fans de Facelets, la librairie est incluse dans la spécification avec les mêmes fonctionnalités et quelques améliorations. Elle inclura aussi Gracelets (Groovy pour JSF / Facelets).
La présentation se focalise ensuite sur un des points noirs de JSF : la création de composant… Vous savez, les composants pour lesquels il faut coder un UIComponent, un Renderer, tag/tld, le (ugly) faces-config.xml…

La création de composants est simplifiée dans JSF 2.0 : soit en utilisant les annotations et le fichier taglibs.xml (configuration ainsi simplifiée) soit les Composite Components, une des grosses nouveautés de cette version. Nous avons ainsi les tags composite:interface et composite:implementation pour définir le composite et l’implémentation.

Ces composites sont accessibles directement dans la webapp ou dans un JAR, avec la possibilité d’ajouter des listeners et converters, de plugger un resource bundle…

L’Ajax n’est pas en reste avec un composant embarqué dans JSF 2.0 : jsf.ajax.request(), utilisable par le tag <f:ajax> qui peut-être soit nested soit wrapping.

Contrôleur

Comme la plupart des frameworks web du moment (Wicket pour ne citer que lui), JSF 2.0 pourra enfin se targuer de supporter… GET (pas de sarcasme svp :)) ! La conséquence directe est que nous allons enfin pouvoir bookmarker nos URLs. Un exemple avant/après :

    

// qui donnera :

Côté événement, le nouveau SystemEvent fonctionne en mode publish/subscribe avec des événements de type PostAddToViewEvent (après la création du composant) et PreRenderViewEvent (avant le rendering du composant).

Une autre partie intéressante est la gestion des ressources dans l’application avec 2 possibilités de récupération selon que la ressource soit présente dans un dossier de la webapp ou dans un JAR :

// Web root

// Classpath of myimages.jar

Modèle

Pour la partie modèle, ce sera surtout une présentation des différentes technologies JEE 6 avec leur intégration dans JSF 2.0 : Managed Beans (partie de JSR-316), Contexts and Dependency Injection (JSR-299), Bean-Validation (JSR-303) et JAX-RS (JSR-311).

Outre les fameuses annotations @Inject (CDI) et @Named (EL), la présentation fera la part belle à Bean-Validation avec l’ajout d’une annotation au niveau de notre POJO qui validera côté Data, Business mais surtout, ce qui nous intéresse, Client.

On se retrouve donc avec les exemples suivants qui sont nativement gérés par JSF 2.0 dans nos pages JSF :

public class User {
   ...
   @NotNull @Size(min=3, max=25)
   public String getUsername() {return username;}
   
   @NotNull @Email
   public String getEmail() {return email;}
}

Il sera toutefois possible, côté JSF, de désactiver certaines validations, soit par paquet soit au cas par cas.

A noter une bonne gestion du null dans un champ (null ou String vide) avec la possibilité de valider ou non le champ si une annotation Bean-Validation est présente ou si le context-param suivant est présent :

   javax.faces.VALIDATE_EMPTY_FIELDS
   true

Mais, il est aussi possible de forcer le champ vide à null avec le paramètre assez explicite suivant :

   javax.faces.INTERPRET_EMPTY_STRING_SUBMITTED_VALUES_AS_NULL
   true

Dernier point abordé, la validation multiple avec plusieurs approches :

• Avant la construction du modèle avec un test de tous les champs sur un événement PostValidateEvent ;
• Après la construction du modèle avec Bean-Validation (mais un objet a déjà été construit… à vous de vous faire votre idée).

BOF

Au niveau des sujets esquivés en conférence, quid d’un projet comme Spring Web Flow pour la gestion d’un flow de page qui est supporté par Seam mais pas par JSF ? Une des réponses est que le projet est plutôt complexe et mériterait peut-être une spécification plus globale pour définir ce qu’est un flow de page, les événements autour de ce flow… Il n’en reste pas moins que JSF 2.0 supporte parfaitement le mode Stateless mais pour l’instant le Stateful ne l’est pas…

Au niveau des tags ajax embarqués, il devrait être assez simple de brancher un jQuery ou un Script.aculo.us sur JSF 2.0 et profiter d’une expérience Ajax complète. Reste à voir l’intégration avec des Composite Components.

Conclusion

Une présentation très rythmée avec beaucoup de slides (peut-être trop) qui ne laissent donc que très peu de temps pour la prise de note. Dommage car certains sujets, non évoqués dans cet article, auraient aussi mérité leur place. Mais ce n’est que partie remise pour un prochain article !

En tout cas, force est de constater que JSF 2.0 tend vraiment à une simplification d’utilisation, orienté annotation et zero-XML. Des Composite Component simples à écrire, une intégration gracieuse avec Bean-Validation… en bref, beaucoup de bons points !