Je m'aperçois avec horreur et stupéfaction que j'ai oublié de vous annoncer la soirée d'hier, qui portait sur JSF 2 et les Servlets 3.0.
Remarquez, je ne sais pas si cela aurait changé quelque chose, les 200 places étant parties en moins d'une journée. Pour avoir une chance de vous inscrire la prochaine fois, je vous recommande vivement de vous abonner à la mailing-list du ParisJUG et à surveiller son compte Twitter.

Pour ceux qui ont donc raté la soirée, en voici un compte-rendu.
Je vous prie de m'excuser pour son aspect assez brut de décoffrage, ce sont les notes que j'ai prises en temps réel lors des présentations, rapidement retouchées - pour le moment, mon emploi du temps ne me laisse pas le loisir de le mettre davantage en forme.

Bonne lecture !

Présentation de JSF 2.0

Cette présentation était animée par Damien Gouyette (Generali) et François Petitit (Octo).

Introduction

JSF est la spécification JavaEE permettant d'implémenter un framework web par composants. Son but est de masquer la complexité du développement web (validation, ajax...) pour augmenter la productivité.
Son impémentation de référence est disponible dans Glassfish, et Apache propose une implémentation alternative avec MyFaces. De plus, de nombreuses librairies de composants supplémentaires existent : RichFaces (JBoss), Tomahawk (Apache), IceFaces, PrimeFaces...

Historique :

• Versions 1.0 et 1.1 en 2004 (JSR 127).
• Version 1.2 en 2006 (JSR 252)
• Version 2.0 en 2009 (JSR 314) : inclus dans JavaEE 6. A noter que JSF fait partie du profil "web" de JavaEE 6, avec les Servlet 3.0.

Les principaux frameworks concurrents sont les applets, JavaFX et Flex parmi les technologies nécessitant des plugins, GWT et Dojo/YUI/jQuery... pour les solutions côté client, et Wicket, Spring MVC, Struts, Stripes pour les frameworks côté serveur.

Architecture du framework JSF

Un framework MVC2

JSF respecte MVC2 :

• Une servlet (faces-servlet) fait office de front-controller. Elle est optionnellement configurable via un descripteur faces-config.xml, qui décrit également la navigation au sein de l'application (JSF2 peut utiliser des annotations à la place).
• Des classes Java appelées Managed Beans servent de modèle. Leurs propriétés sont "bindées" dynamiquement sur la vue de manière bi-directionnelle à l'aide d'un Expression Language, JSF-EL. Ils contiennent également la logique de présentation, et peuvent faire appel à des services de la couché métier.
• Enfin, contrairement au frameworks concurrents, JSF est capable de gérer des vues de différents types. Il gère en interne une représentation abstraite de la vue, qui est ensuite "instanciée" par un Renderer particulier - par exemple, un Renderer HTML pour produire des pages web. Dans la pratique, c'est à 99% des cas un renderer HTML qui est utilisé, avec avec parfois quelques variations comme le support d'Ajax.

Voici un exemple de binding entre un ManagedBean et une vue :

@ManagedBean
@RequestScoped
public class ContactBean {
  private String name; // +getter/setter
}

<h:inputText value=#{contactBean.name}/>

Le cycle complet de traitement d'une requête est le suivant :

1. Réception de la Requête
2. Restauration de l'état de la vue
3. Conversion des paramètres de requêtes en objets Java
4. Validation
5. Mise à jour des Managed Beans
6. Invocation des services métiers
7. Détermination de l'étape suivante de navigation au sein de l'application
8. Génération de la réponse (formatage des données et application du Renderer)
9. Envoi de la réponse.

Validation des données

JSF simplifie la validation des données saisies par l'utilisateur :

• Dans la vue, les balises JSF disposent de nombreux validateurs standards, et il est toujours possible d'en développer de nouveaux.
• Dans les Managed Beans, des méthodes de validation peuvent ajouter des messages d'erreur dans le contexte JSF.

JSF s'intègre également très bien avec la JSR 303 (Hibernate Validator, en version 4.0 depuis quelques jours). De simples annotations sur les propriétés des Managed Beans permettent de définir des contraintes qui sont alors propagées automatiquement à la base de données (via Hibernate) et à la vue (en générant dynamiquement du code de validation Javascript).

Création de composants

JSF est orienté composant. De nombreux composants sont disponibles en standard, qui représentent les éléments HTML de base : boutons, liens, zones de texte...
Evidemment, la richesse d'un tel framework vient surtout de la possibilité d'écrire des composants personnalisés riches et réutilisables, comme un sélectionneur de date ou une galerie d'images.

Sun a apparemment pris en compte les reproches de complexité faits à JSF 1, et propose pour cette nouvelle version un framework appelé EZComp ("easy components").
Il suffit désormais de décrire les attributs du composant ainsi que son rendu dans l'architecture cible ; par exemple, dans le cas d'un rendu web, cela prend la forme d'un fichier XHTML contenant des balises spécifiques.

Damien nous a ainsi montré un composant permettant d'afficher un petit indicateur d'activité lors des requêtes Ajax, qui en quelques lignes de Javascript s'intègre au moteur Ajax de JSF afin de détecter les événements de début et de fin de requête. Son utilisation est ensuite très simple : le code suivant demande la mise à jour d'un certain label en fonction du texte entré dans une zone de saisie :

<h:inputText value="#{contactBean.name}>
	<f:ajax render="nameLabel" />
</h:inputText>

Templating

La fonctionnalité de templating était disponible en JSF1 via le framework Facelets. Celui-ci a été intégré directement dans JSF2.

Le templating se passe en deux phases :

1. Définition de pages modèles définissant des blocs nommés
2. Développement de pages filles qui signalent quel modèle elles utilisent, et définissent le contenu des blocs nommés susmentionnés.

Au final, cela ressemble pas mal à Tiles, les habitués ne seront donc pas perdus.

Mais aussi...

Pour finir, voici en vrac d'autres nouveautés intéressantes :

• JSF 2.0 permet maintenant de servir des ressources statiques (images, JS, CSS...) depuis le répertoire META-INF/resource, qu'il soit placé dans l'application ou dans les jars la composant. Notez que les ressources peuvent même être internationalisées : il suffit de préfixer leur nom par le symbole de la Locale correspondante (ex: en_logo.gif, fr_logo.gif...).
• JSF 2.0 définit des profils d'utilisation : développement, production, test... Cela permet de paramétrer différemment l'application en fonction de son environnement d'exécution, par exemple en affichant les stacktraces lors du développement mais pas en production.
• Support de Groovy pour les composants JSF (ManagedBeans, validateurs, convertisseurs...)
• Gestion des requêtes GET en plus de POST, de manière à avoir des URLs bookmarkables.

Conclusion

Cette nouvelle version majeure tente de simplifier le développement d'applications JSF (annotations, EZComp...), et amène son lot de nouveautés bienvenues (Ajax, profils, requêtes GET, gestion des ressources statiques...)

Personnellement, je peine à trouver JSF attirant ni pratique. J'allais pourtant à cette présentation avec un certain enthousiasme, suite à la revue flatteuse du Touilleur-Express sur le sujet ; je me disais qu'il était temps de redonner une chance au produit.
Au final, en tant qu'utilisateur de Wicket, j'ai été assez déçu - par JSF, non par la présentation de Damien : les vues web et les composants ne sont pas prévisualisables (à cause des balises propriétaires), le templating est encore rudimentaire, et les performances sont nettement en retrait (voir cette comparaison des principaux frameworks web).
En attendant JSF 3.0, Je vous laisse vous faire votre propre opinion sur le sujet !