Est-ce que le code suivant compile ? public class MyException<T> extends Exception { } Réponse : (cliquez pour afficher)

Non.

Explication :

La spécification du langage précise explicitement : "It is a compile-time error if a generic class is a direct or indirect subclass of Throwable." (Traduction : "C'est une erreur de compilation si une classe générique hérite directement ou indirectement de Throwable").

En effet, le mécanisme de catch des exceptions en Java ne fonctionne qu'avec des classes non génériques. C'est pour cela que les classes héritant de Throwable ne peuvent pas être typées avec des generics.

Sources :

• Java Language Specification, §8.1.2

Ceci est le premier post d'une longue (j'espère) série de questions : l'Aperiquiz.

Le principe est simple : mettre en évidence un point précis de la spécification Java en se basant sur un exemple de code inhabituel, une question tordue ou une particularité peu connue du langage.

Prêts ? C'est parti !

Considérant le code suivant :

public class Main {

    public static String myMethod() {
        try {
            return "try";
        } catch (Exception e) {
            return "catch";
        } finally {
            return "finally";
        }
    }

    public static void main(String[] args) {
        System.out.println(myMethod());
    }

}

Quel est le résultat ?

• try
• catch
• finally

Réponse : (cliquez pour afficher)

finally

Sources :

• Stack Overflow : Questions to indicate competency in Java (merci à Martin pour le lien)

Avec une installation par défaut de GlassFish, l'utilisation de JMS au sein du serveur d'application amène souvent à l'erreur suivante :
DirectConsumer:Caught Exception delivering messagecom.sun.messaging.jmq.io.Packet cannot be cast to com.sun.messaging.jms.ra.DirectPacket

Cette erreur n'est pas fatale, l'application est tout de même déployée et les différents messages sont envoyés et reçus. Cependant, cette erreur est générée à chaque envoi de message, ce qui peut rapidement devenir encombrant dans les fichiers de log de GlassFish.

Cette exception viens du mode de configuration utilisé pour le lancement du service JMS dans GlassFish. Par défaut, le service est lancé en mode EMBEDDED. Le service JMS tourne dans le même processus que le serveur GlassFish, ce qui provoque ce genre d'erreurs.

Il est possible de changer ce mode de lancement du service JMS. Il suffit de lancer ce même service en mode LOCAL pour que le service tourne dans un processus séparé du serveur GlassFish (mais toujours sur la même machine). Le service JMS sera toujours contrôlé par GlassFish (lancement simultanés entre autre). Changer ce mode de fonctionnement du service JMS permet de résoudre ce problème de cast de messages.

Pour effectuer ce changement, il faut se rendre dans la console d'administration de GlassFish :

• Accéder à l'adresse http://localhost:4848/
• Se connecter avec les identifiants d'administration de GlassFish (par défaut : admin /// adminadmin)
• Cliquer sur "Configuration" -> "Java Message Service" dans le menu de navigation de gauche
• Modifier la propriété "Type" et lui donner la valeur de "LOCAL"

Après avoir installé RichFaces, je me suis lancé dans la rédaction d'une page d'exemple, histoire d'apprendre le fonctionnement de cette librairie qui semble bien intéressante.

Le but de cette page d'exemple est de mettre en place une DataTable, avec fonctionnalités de tri et de filtres. Toutes ces fonctionnalités utiliseront de l'Ajax, et il ne sera donc pas nécéssaire de recharger la page afin de voir les changements.

Les contacts contenus dans notre DataTable devront être triés par nom de famille par défaut. Il sera également possible pour l'utilisateur de changer l'ordre de tri (croissant, décroissant), ainsi que la propriété servant à effectuer ce tri (prénom, nom, ou adresse mail).

Enfin, pour le filtre, nous aurons un champ de texte qui limitera la liste aux contacts :

• Dont le nom commence par la requête
• Dont le prénom commence par la requête
• Dont l'adresse mail contient la requête

Mise en place d'une Rich DataTable

Afin de commencer notre page d'exemple, nous allons créer une classe Contact, qui aura pour vocation de contenir les données. Cette classe est un JavaBean, et possède donc les caractérisques suivantes :

• Les propriétés doivent être privées
• Chaque propriété doit avoir des accésseurs (getters et setters) publics
• La classe doit avoir un constructeur par défaut
• La classe doit implémenter Serializable

Nous allons donc créer notre classe Contact avec les propriétés firstName, lastName et mailAddress : public class Contact implements java.io.Serializable { private String firstName; private String lastName; private String mailAddress; public Contact() { } public Contact(String firstName, String lastName, String mailAddress) { this.firstName = firstName; this.lastName = lastName; this.mailAddress = mailAddress; } // Getters and setters }

La seconde étape sera de créer un managed bean JSF, qui nous renvera une liste de contacts d'exemple : public class DataTableManager { // Returns sample data public DataModel getSampleModel() { List<Contact> contacts = new ArrayList<Contact>(); contacts.add(new Contact("Toto", "Tata", "toto@tata.com")); contacts.add(new Contact("John", "Doe", "john@doe.com")); contacts.add(new Contact("Alan", "Smithee", "alan@smithee.com")); contacts.add(new Contact("Vivien", "Barousse", "barousse.vivien@gmail.com")); contacts.add(new Contact("Titi", "Tata", "titi@tata.com")); contacts.add(new Contact("Foo", "Bar", "foo.bar@provider.com")); contacts.add(new Contact("Bar", "Baz", "bar.baz@provider.com")); contacts.add(new Contact("Gloubi", "Boulga", "gloubi@goulba.com")); return (new ListDataModel(contacts)); } }

Et enfin, dernière étape, nous allons créer notre Rich DataTable, basique pour l'instant, capable d'afficher ces données : <rich:dataTable value="#{DataTableManager.sampleModel}" var="contact"> <f:facet name="header"> <h:outputText value="Sorting & Filter exemple" /> </f:facet> <rich:column> <f:facet name="header"> <h:outputText value="First name" /> </f:facet> <h:outputText value="#{contact.firstName}" /> </rich:column> <rich:column> <f:facet name="header"> <h:outputText value="Last name" /> </f:facet> <h:outputText value="#{contact.lastName}" /> </rich:column> <rich:column> <f:facet name="header"> <h:outputText value="Mail address" /> </f:facet> <h:outputText value="#{contact.mailAddress}" /> </rich:column> </rich:dataTable>

Nous avons dans l'exemple de code précédent créé une Rich DataTable. Le code ressemble à celui d'une DataTable classique, la seule différence étant l'utilisation de la taglib RichFaces au lieu de la taglib standard.

Rajout des fonctionnalités de tri

L'ajout du tri dans une Rich DataTable est très facile. La balise <rich:column /> possède un attribut sortBy, qui permet de spécifier la propriété qui sera utilisée pour trier la colonne concernée.

Notre code précédent ressemble donc désormais à ceci : <rich:dataTable value="#{DataTableManager.sampleModel}" var="contact"> <f:facet name="header"> <h:outputText value="Sorting & Filter exemple" /> </f:facet> <rich:column sortBy="#{contact.firstName}"> <f:facet name="header"> <h:outputText value="First name" /> </f:facet> <h:outputText value="#{contact.firstName}" /> </rich:column> <rich:column sortBy="#{contact.lastName}"> <f:facet name="header"> <h:outputText value="Last name" /> </f:facet> <h:outputText value="#{contact.lastName}" /> </rich:column> <rich:column sortBy="#{contact.mailAddress}"> <f:facet name="header"> <h:outputText value="Mail address" /> </f:facet> <h:outputText value="#{contact.mailAddress}" /> </rich:column> </rich:dataTable>
L'exécution de ce code nous montre que sur chaque colonne, RichFaces a rajouté des boutons permettant à l'utilisateur de choisir quelle colonne sera utilisée pour trier les données, et de choisir l'ordre de tri.

Il est également possible de donner un ordre de tri par défaut à notre DataTable. Pour celà, nous allons utiliser l'attribut sortOrder de notre balise <rich:column /> : <rich:column sortBy="#{contact.lastName}" sortOrder="ASCENDING"> <f:facet name="header"> <h:outputText value="Last name" /> </f:facet> <h:outputText value="#{contact.lastName}" /> </rich:column>
Ainsi, au lancement de la page, les contacts seront triés par ordre alphabétique en fonction de leur nom de famille. Il sera également possible pour l'utilisateur de changer la propriété servant à faire le tri (et de choisir le prénom, ou l'adresse mail). L'utilisateur aura également la possibilité de changer l'ordre de tri (croissant, décroissant).

Filtrer les données

Le filtrage des données à l'intérieur d'une DataTable passe par plusieurs étapes :

• Il faut commencer par créer un champ de texte, permettant à l'utilisateur de rentrer la requête sur laquelle nous allons nous baser pour filtrer les entrées
• Il faudra ensuite créer une méthode permettant de filter chacune de nos entrées. Cette méthode prends en paramètre l'objet à filter, et renvoie un booléen indiquant si l'objet doit être affiché
• Enfin, il faudra que notre DataTable soit mise à jour à chaque modification de la requête

La première étape est donc de créer notre champ de texte. Il s'agit d'un simple champ de texte JSF (<h:inputText />) que nous allons lier à une propriété d'un managed bean : public class DataTableManager { // [...] // Filtering private String filterValue; public String getFilterValue() { return filterValue; } public void setFilterValue(String filterValue) { this.filterValue = filterValue; } } Puis le code JSP correspondant : <h:inputText value="#{DataTableManager.filterValue}" id="lastNameFilterText"> </h:inputText>
Seconde étape, toujours dans notre managed bean, nous allons créer une méthode filtrant les objets de type Contact en fonction de la requête qui nous est envoyée par le champ de saisie. Dans l'exemple ci dessous, la méthode doFilter prends en paramètre l'objet que nous allons devoir filtrer (dans notre cas, on objet de type Contact), et dois renvoyer true si le contact doit être affiché, false sinon : public class DataTableManager { // [...] public boolean doFilter(Object value) { if (filterValue == null) { return (true); } Contact contact = (Contact) value; if (contact.getFirstName().toLowerCase() .startsWith(filterValue.toLowerCase())) { return (true); } if (contact.getLastName().toLowerCase() .startsWith(filterValue.toLowerCase())) { return (true); } if (contact.getMailAddress().toLowerCase() .contains(filterValue.toLowerCase())) { return (true); } return (false); } } Nous allons également dire à notre DataTable d'utiliser cette méthode afin de filtrer les entrées à afficher : <rich:column sortBy="#{contact.firstName}" filterMethod="#{DataTableManager.doFilter}"> <f:facet name="header"> <h:outputText value="First name" /> </f:facet> <h:outputText value="#{contact.firstName}" /> </rich:column>
Enfin, dernière étape, nous allons préciser à RichFaces que notre champ de texte doit automatiquement rafraîchir, en Ajax, notre DataTable afin que les données soient de nouveau filtrées, avec la nouvelle requête : <h:inputText value="#{DataTableManager.filterValue}" id="lastNameFilterText"> <a4j:support event="onkeyup" reRender="dataTable" requestDelay="500" /> </h:inputText> La balise <a4j:support /> permet, entre autres, de mettre rafraîchir un composant. Elle prends 3 paramètres :

• event : l'évènement JavaScript qui devra déclencher le rafraîchissement
• reRender : le composant à rafraîchir
• requestDelay : permet de spécifier un délai entre la requête et le refraîchissement du composant

A chaque fois que la valeur du champ de texte est modifiée, la nouvelle valeur est envoyé dans notre managed bean, et notre DataTable est raffraîchie. Ainsi, le tableau va de nouveau être filtré, et notre méthode va permettre d'éliminer certains résultats de notre tableau.


Nous avons donc vu un premier exemple de fonctionnalité Ajax qu'il est possible de réaliser grâce à RichFaces. Une DataTable avec fonctionnalités de tri et de filtre, qui se rafraîchit sans recharger la page.

Les sources du projet NetBeans de cet article sont disponnibles ici.

Je continue dans ma recherche de librairie de composants pour JSF. J'avais déjà testé ICEFaces, mais elle ne me satisfaisait pas. Trop de changement au niveau du cycle de vie de JSF à mon goût.

J'ai testé aujourd'hui une nouvelle librairie, qui à l'air de s'intégrer parfaitement à JSF. Très peu de changements dans le cycle de vie JSF, beaucoup de composants, dont la plupart en Ajax. Il s'agit de RichFaces.

L'installation, comparée à celle de ICEFaces, est très simple. Quelques librairies, quelques dépendances (BeanUtils, Collections, Digester, Commons Log). La seule configuration nécessaire est la déclaration d'un filtre dans le fichier web.xml : <filter> <display-name>RichFaces Filter</display-name> <filter-name>richfaces</filter-name> <filter-class>org.ajax4jsf.Filter</filter-class> </filter> <filter-mapping> <filter-name>richfaces</filter-name> <servlet-name>Faces Servlet</servlet-name> <dispatcher>REQUEST</dispatcher> <dispatcher>FORWARD</dispatcher> <dispatcher>INCLUDE</dispatcher> </filter-mapping>
Il ne reste plus qu'à tester la liste assez imposante de composants proposés :)