Une fois n'est pas coutume, je vais parler de moi.

Comme ceux qui me suivent fréquemment ont pu le constater, mon rythme de rédaction s'est énormément ralenti ces derniers temps, principalement depuis le début du mois de juin. Je vais essayer d'en expliquer les raisons et de rassurer certains de mes lecteurs pour la suite. La raison pour laquelle je ne blogue plus beaucoup ces derniers temps est presque évidente.

C'est la fin de l'année scolaire

Les étudiants sont partis en stage, alors que le mien ne commence que début août. Je suis en quelque sorte en vacances. Mon blog est nourri principalement d'échanges avec les gens que je côtoie tous les jours à SUPINFO, avec les élèves. Depuis la fin du mois de juin, le nombre de personnes avec lesquelles je discute "Java" à fortement diminué. D'où une baisse des questions qui nécessitent une réponse. D'où une baisse du nombre d'articles sur ce blog.

Mon stage commence précisément le 4 août. Mon rôle sera de préparer les PEFF (Peut-être futurs formateurs, comme dirait Mauricio) afin qu'ils soient capables de dispenser des cours dès le mois d'octobre. Ce "stage" s'est révélé très intéressant l'an dernier, notamment grâce à une intervention de Alexis Moussine-Pouchkine sur GlassFish. J'espère que celui de cette année le sera tout autant. Entouré de geeks du Java, de geeks tout court, j'espère pouvoir reprendre mes échanges sur le monde Java, pouvoir reprendre plus activement la rédaction de ce blog.


En attendant le début du mois d'août, d'ici deux semaines, je ne bloguerais quasiment pas. Pour ceux qui cherchent désespérément de la lecture, je peux vous conseiller pour l'été :

• "EJB 3 - Des concepts à l'écriture du code. Guide du développeur", écrit par le laboratoire Sun (et auquel j'ai participé), chez Dunod. La seconde édition est sortie il y a à peine quelques jours. Je n'en avais pas encore parlé, voilà qui est chose faite.
• Java.Blogs. À mon avis un des meilleurs agrégateurs de blogs Java, très utile pour se tenir au courant des tendances actuelles.

La blogosphère en parle beaucoup depuis ce matin (ici, là, ou encore là), la première milestone de NetBeans 6.5 est sortie.

L'annonce officielle nous propose un petit aperçu des nouvelles fonctionnalités.

La nouveauté majeure de cette version 6.5 semble l'apparition de l'éditeur PHP (présentation des fonctionnalités, screencast, tutorial). Le blog NetBeans for PHP à également fait son apparition récemment.

D'autres améliorations sont également au programme, notamment en ce qui concerne les éditeurs JavaScript (Ajax), Groovy et Java.

Le meilleur moyen de se faire une idée reste encore et toujours de la tester par soi même. Téléchargement ici.

Si vous lisez ces quelques lignes, c'est que je ne me serais planté nulle part. Ou du moins que mes erreurs ne sont pas critiques.

La résiliation de l'abonnement Internet étant en cours, mon blog, qui était jusqu'à présent hébergé chez moi, avait devant lui des jours qui lui étaient comptés.

C'est pour cela que j'ai migré mon installation de Roller vers un nouveau serveur, loué pour l'été (voire plus...) chez OVH (un Kimsufi, qui me suffit pour l'instant).

A première vue tout marche, j'essayerais de réparer les éventuels défauts dans les jours à venir... En attendant, bonne lecture :)

Depuis Java 5, le langage Java dispose d'une nouvelle fonctionnalité : les énumérations.

Les énumérations sont des structures permettant de représenter une variable ayant un nombre fini de valeurs, comme par exemple le sexe d'une personne, qui sera soit "homme", soit "femme".

Les énumérations sont mises en place de la manière suivante :

enum Sex {
    MALE,
    FEMALE;
}

Il est ensuite possible de créer des variables du type de l'énumération, et de les utiliser :

Sex sex = Sex.MALE;
System.out.println(sex);

Et c'est là qu'apparaît notre problème : la console nous affiche "MALE". Certes, il s'agit de la bonne valeur, mais la présentation n'est pas très esthétique. Heureusement pour nous, en Java une énumération est également un objet. Il nous est possible de définir nos propres méthodes, et aussi de récrire certaines méthodes de la classe Object. Ainsi, on peut avoir le code suivant :

enum Sex {
    MALE,
    FEMALE;
    
    @Override
    public String toString() {
        switch (this) {
            case MALE:
                return ("Male");
            case FEMALE:
                return ("Female");
        }
        throw new RuntimeException("Invalid value for this");
    }
}

L'exécution du même code nous donne ainsi "Male" au lieu de "MALE". On obtient le résultat souhaité, à savoir une chaîne de caractères plus facilement lisible par l'utilisateur.

Le soucis que l'on rencontre maintenant viens du switch dans la méthode toString. Nous devons gérer toutes les valeurs possible dans cette méthode, sous peine de lancer une RuntimeException. Une des solutions possibles (que j'ai trouvé dans un commentaire d'un (très) vieux billet de blog), et que je trouve de loin ma préférée, est de fournir un constructeur à notre énumération. Ce constructeur prend en paramètre une chaîne de caractères qui sera utilisée en tant que valeur de retour de la méthode toString :

enum Sex {
    MALE("Male"),
    FEMALE("Female");
    
    private String value;
    
    private Sex(String value) {
        this.value = value;
    }
    
    @Override
    public String toString() {
        return (value);
    }
}

Ainsi, nous obtenons on comportement optimal :

• Chaque valeur de l'énumération renverra une chaîne de caractères "esthétique" représentant sa valeur
• Chaque valeur devra posséder une chaîne de caractères (au risque de générer une erreur de compilation)

Le problème majeur qui est ainsi rencontré concerne la conversion énumération -> chaîne de caractères -> énumération. La chaîne de caractères renvoyait de base par toString était le nom de la constante dans l'énumération (MALE ou FEMALE dans notre cas), qui pouvait ensuite être reconverti en énumération via la méthode valueOf. Dans notre cas, la conversion ne se ferra plus puisque toString ne renverra plus une valeur compréhensible par valueOf. Cependant, la méthode name, définie dans toute énumération, renvoie toujours le nom de la constante tel que définit dans le code.

Pour éviter les erreurs, voici un rapide rappel pour faire de l'inclusion de pages en JSF. Cet article contient un exemple de code classique, puis quelques points à ne pas oublier pour que tout se passe bien.

Le but de cet exemple sera d'avoir une page index.jsp qui inclue une page content.jsp.

index.jsp

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>JSP Page</title>
    </head>
    <body>
        <f:view>
            <f:subview id="content">
                <jsp:include page="content.jsp" flush="false" />
            </f:subview>
        </f:view>
    </body>
</html>

content.jsp

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<h:outputText value="Ceci est le contenu !" />

Points importants

Il existe quelques règles assez importantes pour que ce système d'inclusion de page marche correctement :

• Dans la page de base, entourer l'inclusion avec une balise <f:subview />
• Lors de l'inclusion, penser à mettre l'attribut flush à false. Cet attribut existe sur la plupart des balises permettant l'inclusion de pages.
• Dans la page de destination, réutiliser les composants JSF directement, sans remettre de balise <f:view />
• Les taglibs doivent quand à elles être réimportées.

Et voilà le résultat (en HTML) :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>JSP Page</title>
    </head>

    <body>
        Ceci est le contenu !
    </body>
</html>

Martin en parle également.