Bla bla blog

A noter l'excellent dossier consacré à Android dans le mensuel "Programmez". Plusieurs connaissances dont Olivier Penhoat y ont contribué.

Bonne lecture !

Ayant eu le problème récemment, je vous conseille cet excellent article en français sur le sujet.

Pour résumer, il suffit de demander le chargement du fichier .ttf à la compilation de votre application tout en lui associant un nom logique. Ce nom logique vous permettra de désigner votre nouvelle police lorsque vous souhaiterez l'associer à un composant via la propriété css fontFamilly par exemple.

<mx:Style>
        global {
            fontFamily: chollSanReg;
        }
        </mx:Style>
        <mx:Script>
                <![CDATA[
                        [Embed(source="assets/fonts/ChollSanReg.ttf", fontName="chollSanReg")]
                        private var _chollSanReg:Class;
                ]]>
        </mx:Script>

Il est très intéressant d'embarquer vos propres polices dans vos applications Flex, car mis à part le fait que swf final est un peut plus lourd, si vous effectuez des rotation sur votre composant le texte avec votre police continuera d'apparaître, les effets de transparence (alpha) fonctionnent sur les polices embarquées et vous obtenez une meilleure définition lorsque vous zoomez sur votre texte.

Dans ZF (Zend Framework) le mapping objet relationnel a été défini via les design patterns "table data gateway" et "row data gateway" inventés par Martin Fowler. Ces patterns permettent d'accéder ou de manipuler le contenu de table via des objets, ici ces objets seront de simples wrapper de notre structure relationnelle, donc chaque table est associée à une classe qui sera définie par le développeur en respectant un certain nombre de règles (héritage, redéfinition, etc) que nous verrons ici.

Un exemple de modèle relationnel

Pour illustrer les possibilités offertes par ce framework, nous prendrons un exemple simple : le forum de discussion, dont le modèle relationnel simplifié serait le suivant :

Donc simplement trois tables, avec une clé primaire id auto incrémentée sur chaque table et des clés étrangères de posts vers topics et de topics vers forums.

Définition du mapping

En respectant les principes des patterns précités, nous obtenons donc trois classes qui héritent de la classe Zend_Db_Table (fournie par ZF)

Personnalisation du mapping

Toutefois ce mapping ne fonctionnera qu'à condition que votre table porte exactement le même nom que votre classe et que la clé primaire soit le champ ID et qu'elle soit auto-incrémentée. Pour tout autre cas de figure il faudra redéfinir les attributs $_name, $_id et $_sequence dans votre classe. Ainsi pour la classe Topic, nous aurons le code suivant :

<?php
require_once("Zend/Db/Table.php");

class Topic extends Zend_Db_Table{
    
    protected $_primary="id"; //clé primaire 
    protected $_sequence=true; //true est la valeur par défaut, pour une clé primaire auto-incrémentée
                                              //false entraîne l'obligation pour le développeur de renseigner la valeur de sa clé
                                              //une chaîne de caractère, pour les PK de type séquence (uniquement sur certains type de SGBDR)
    protected $_name="topics"; //nom de la table correspondant à cette classe

}
?>

Définition des relations

Dans ZF, la définition des relations doit être faite dans chaque classe. Elle s'appuie sur les relations définies au niveau de la base de données, c'est à dire les clés étrangères. Cette définition est importante car elle permet de "naviguer" dans la grappe d'objets récupérée, par exemple récupérer tous les posts relatifs à un topic, ou à partir d'un post retrouver son topic.

Prenons l'exemple de la table TOPICS, chaque enregistrement dans cette table doit référencer via une clé étrangère une entrée dans la table FORUMS, tout comme les enregistrements dans la table POSTS doivent référencer les entrées dans la table TOPICS. Voyons comment matérialiser ces relations au niveau de la classe Topic :

<?php
require_once("Zend/Db/Table.php");

class Topic extends Zend_Db_Table{
   [...]  

   //$_refernceMap est un tableau associatif qui représente toutes les clés étrangères ou relations de la 
   //table TOPICS avec d'autre tables
   protected $_referenceMap=array("forumKey"=>array(                 //forumKey est l'identifiant de cette relation, utile pour requêter la structure objet lorsqu'il y a plusieurs relations
                                                     "columns"=>array("forum_id"),  //Nom de la colonne portant la clé étrangère
                                                     "refTableClass"=>"Forum",       //Nom de la table référencée
                                                     "refColumns"=>array("id")));     //Nom de la colonne référencée (PK)

  //Noms de toutes les tables qui ont des relations avec la table TOPICS  
  protected $_dependentTables=array("Post");

}
?>

Nous venons de voir comment définir un mapping objet relationnel avec le module Zend_Db de ZF. Pour aller plus loin je vous propose la documentation de ZF.

Le cross-browsing est votre cheval de bataille depuis que vous vous êtes lancé dans l'aventure du web, voici la solution universelle pour gérer les tailles et positionnements de vos applications : http://users.telenet.be/kixx/

Voilà bientôt dix ans que je n'avais pas installé une distribution Linux digne de ce nom, il faut dire que mes précédentes expériences étaient douloureuses... Ceci est désormais du passé grâce notamment à ce tutoriel très didactique que je voulais très simplement vous partager.

Ce guide décortique pour vous toutes les étapes pour une installation réussie, du partitionnement optimal à la cohabitation avec Windows. Personnellement j'ai vraiment apprécié. Je n'ai d'ailleurs pas pu résister une fois l'installation terminée, à l'envie d'écrire une petite classe Java sous vi, en me rappelant au bon souvenir des commandes de cet éditeur fantastique !

Me voici réconcilié avec les pingouins..

Introduction

Cet article met l'accent sur la nouvelle série d'annotations introduites qui peuvent être utilisés par les développeurs plutôt que de mettre les données dans le fichier de configuration

Facilité de développement par Annotations

Les informations sur les composants Web tels que les Servlets, Servlet filtres sont mentionnées dans le descripteur de déploiement, qui est web.xml. A partir de Servlet 3.0, il est également possible de spécifier des méta-informations sur un élément (classe, interface), cette opération se fera via les annotations. Le fichier web.xml ne disparait pas pour autant. D'ailleurs les informations qu'il contient sont toujours prioritaires sur celles des annotations. Il est également possible d'activer ou pas la prise en charge des annotations par le conteneur via la balise <metadata-complete> directement placée sous la balise <web-app> du fichier web.xml. Cette balise attend les valeur "true" (le web.xml est complet, il se suffit à lui même) ou false (dans ce cas les annotations devraient être prises en compte)

Les annotations suivantes sont applicables à partir de spécifications Servlet 3.0,

    * @WebServlet 
    * @WebServletContextListener 
    * @ServletFilter 
    * @InitParam

Annotations WebServlet et InitParam

Dans cette section, nous allons voir l'utilisation de @WebServlet et @InitParam par un exemple.

package net.javabeat.servlet30.newfeatures;

import javax.servlet.annotation.InitParam;
import javax.servlet.annotation.WebServlet;

@WebServlet(
    name = "SimpleServlet", 
    urlPatterns = {"/simple"}, 
    initParams = {
        @InitParam(name = "param1", value = "value1"),
        @InitParam(name = "param2", value = "value2")}
)
public class SimpleServlet {

}

Dans cet exemple, nous avons créé une classe SimpleServlet qui n'hérite pas de HttpServlet, contrairement à ce que prévoit la spécification originale. En revanche, pour bénéficier de cette classe comme une classe Servlet, nous avons annoté en utilisant l'annotation @ WebServlet. Notez que le nom de la servlet est SimpleServlet comme spécifié par l'attribut name. L'attribut urlPatterns définit un ensemble de modèles url-qui peut être utilisé pour invoquer la Servlet. Voici le descripteur de déploiement équivalant :

<servlet>
    <servlet-name>SimpleServlet</servlet-name>
    <servlet-class>net.javabeat.servlet30.newfeatures.SimpleServlet</servlet-class>

        <init-param>
            <param-name>param1</param-name>
            <param-value>value1</param-value>
        </init-param>

        <init-param>
            <param-name>param2</param-name>
            <param-value>value2</param-value>
    </init-param>

</servlet>

<servlet-mapping>
    <url-pattern>/simple</url-pattern>
    <servlet-name>SimpleServlet</servlet-name>
</servlet-mapping>

Dans sa version 1.7, ZF (Zend Framework) a vu pas mal de nouveautés, parmi lesquels il faut d'après moi relever les extensions :

• Zend_AMF pour un support du protocole AMF d'Adobe. On peut ainsi imaginer un frontal Flex/AS/Flash avec un back-end PHP, c'était déjà le cas avant via HTTP ou les web services, l'intérêt du protocole AMF étant de permettre au serveur de mettre à jour les clients sans qu'ils ne l'aient sollicité.
• ZendX_JQuery pour un support du célèbre framework AJAX qui est en train de supplanter tous ces concurrents. Pour vous faire une idée des widgets mis à votre disposition, et la manière d'utiliser cette extension je vous conseille cette démo

Pour le reste des nouveautés il s'agit surtout de mise à jour des librairies existantes, d'amélioration des perf pour le Zend_Loader et de la corrections de quelque 300 bugs.

Voici un post qui donne un peu plus de détail :

Zend Framework 1.7.0 is now available from the Zend Framework download site: http://framework.zend.com/download/latest

This release introduces many new components and features, including:

* Zend_Amf with support for AMF0 and AMF3 protocols * Dojo Toolkit 1.2.1 * Support for dijit editor available in the Dojo Toolkit * Zend_Service_Twitter * ZendX_JQuery in extras library * Metadata API in Zend_Cache * Google book search API in Zend_Gdata * Preliminary support for GData Protocol v2 in Zend_Gdata * Support for skip data processing in Zend_Search_Lucene * Support for Open Office XML documents in Zend_Search_Lucene indexer * Performance enhancements in Zend_Loader, Zend_Controller, and server components * Zend_Mail_Storage_Writable_Maildir enhancements for mail delivery * Zend_Tool in incubator * Zend_Text_Table for formatting table using characters * Zend_ProgressBar * Zend_Config_Writer * ZendX_Console_Unix_Process in the extras library * Zend_Db_Table_Select support for Zend_Paginator * Global parameters for routes * Using Chain-Routes for Hostname-Routes via Zend_Config * I18N improvements - Application wide locale for all classes - Data retrieving methods are now static - Additional cache handling methods in all I18N classes - Zend_Translate API simplified * File transfer enhancements - Support for file elements in subforms - Support for multifile elements - Support for MAX_FILES_SIZE in form - Support for breaking validation chain - Support for translation of failure ,messages - New IsCompressed, IsImage, ExcludeMimeType, ExcludeExtension validators - Support for FileInfo extension in MimeType validator * Zend_Db_Table_Select adapater for Zend_Paginator * Support for custom adapters in Zend_Paginator * More flexible handling of complex types in Zend_Soap

In addition, almost three hundred bugs have been fixed:

http://framework.zend.com/issues/sec...equestId=10903

The Zend Framework team would like to thank everyone who made this release possible. As always, our generous ZF community has provided countless new features, bug fixes, documentation translations, etc. We'd also like to thank Adobe Systems and Wade Arnold for contributing the new Zend_Amf component. A big thanks to PHP Belgium and everyone who participated in bug hunt day (http://www.bughuntday.org/) and/or the Zend Framework bug hunt week. Finally, we'd like to thank all of those whom we've forgotten to thank above. Once again, we're reminded that Zend Framework is about much more than code, it is about community. See y'all online.

,Wil

Là où certains scandent le mot fraternité, d'autres plus proche du monde IT semblent adopter le mot modularité. Quand je pense que sur les bancs de l'école on nous disait alors que l'approche objet permettait la réutilisabilité, qu'on allait pouvoir travailler indépendamment sur des couches (modules) distinctes et réutilisables... En fait en prenant un peu de recule, en phase de développement effectivement nos packages nous permettent de correctement distinguer les couches d'accès au données, présentation, etc. En plus si on utilise des frameworks comme maven, la structure de notre projet fera clairement apparaître nos différents artefacts en vue du build. Mais force est de constater qu'une fois le build effectué, l'archive à déployer fera moins apparaître cette modularité. Prenons un EAR, certes il sera par exemple composé d'un war et d'un ou plusieurs JAR pour les couches de services et d'accès aux données, mais dans un tel découpage on retrouvera les classes métiers, les interfaces des façades, et toutes les classes communes aux différentes archives.

Java 7.0 et la modularité

Comme le fait remarquer Alex Moussine Pouchkine (Architecte Java chez Sun) : "le système de package de Java est obsolète et pose les mêmes problème que les DLL de Microsoft". La JSR 277 a donc vu le jour chez SUN pour remplacer le système d'archive actuel (jar, war et ear) et la première implémentation de cette JSR devrait voir le jour dans la prochaine version du JDK, soit Java 7.0. Issues de la spec, voici les réponses que devra apporter cette JSR 277 également appelée Java Module System (JMS rien à voir avec Java Messaging System) :

1. Un nouveau format de distribution des classes java et ressources associées, ainsi qu'un nouveau format pour les métadonnées associées au module.
2. Une spécification pour réaliser un référentiel de modules (exit les référentiels Maven ??)
3. Les métadonnées indiqueront :

• une description du contenu du module
• les dépendances vis à vis d'autres modules en précisant les versions de ces derniers
• l'ensemble des ressources (Java et autres) accessibles depuis d'autres modules

Je ne sais pas ce que vous en pensez, mais ça me rappelle étrangement la notion de bundle OSGi, comme les plugins Eclipse, dans lesquels on trouve exactement les mêmes notions. J'avoue partager le constat sur les limitations des archives d'un point de vue modularité, mais de là à définir un nouveau standard... serait-ce un choix politique plutôt que technique ? Pour aller plus loin, je vous conseille ce billet provenant de l'OSGi Alliance.

GlassFish et la modularité

Au delà de la prochaine version de Java, on parle également de la sortie prochaine de Java EE 6 et surtout du premier serveur d'application qui implémentera cette nouvelle mouture : GlassFish V3. Les atouts mis par Sun pour la nouvelle version de GlassFish sont : la modularité, l'extensibilité, la possibilité de déployer ou supprimer de nouveaux services "à chaud". Cette approche permettra de définir des profils d'utilisation de GlassFish et donc de supprimer certains services couteux (RMI, JMS, JNDI, EJB, WS, etc.), mais Sun nous indique qu'il sera possible de réinstaller ces services à tout moment et sans redémarrer le serveur d'application. Pour parvenir à ce résultat la plate-forme de GlassFish reposera sur... OSGi (?)

Suite à la présentation qui a été faite de SWTBot, nous allons présenter dans cette article un exemple de test sur une application développée avec SWT. Nous avons choisi une application de Tchat avec deux tests à réaliser : s'assurer que les composants graphiques sont bien présents et qu'après l'envoi d'un message la zone de saisie est de nouveau vide.

Classe de test

Définition

Les classes de tests dans SWTBot doivent hériter de SWTBotTestCase. Cette classe hérite elle-même de la classe TestCase de JUnit, ce qui prouve que SWTBot est une extension du framework JUnit. Cela signifie également que vous aurez la possibilité de redéfinir les méthode setUp() et tearDown() dans vos classes de test.

Démarrage de l'application

Pour plus de facilité, c'est la classe de test qui va démarrer notre application graphique dans un autre thread. Nous allons donc ajouter une partie static qui se chargera du lancement de l'application à tester au chargement de la classe de test.

static {
    startApplicationInAnotherThread();
}
private static void startApplicationInAnotherThread() {
    new Thread(new Runnable() {
        public void run() {
            new ChatView().main(new String[]{});
        }
    }).start();
                
    long endTime = System.currentTimeMillis() + 5000;
    while (System.currentTimeMillis() < endTime) { 
    try {
        Display display = SWTUtils.display();
        if (display != null)
            break;
    } catch (Exception e) { }
    }
}

On voit dans cet exemple que l'application ChatView est démarrée, puis on essaie de récupérer l'objet Display dans un boucle while pour s'assurer que l'application graphique a bien été démarrée avant de commencer l'exécution des tests

Ecriture des tests

Les méthodes de test doivent toutes être nommée testXXX(), Il s'agit d'une convention reprise de JUnit. Puis il s'agit de récupérer des références sur les objets graphiques de l'interface, cette opération se fait via l'attribut bot, qui est hérité de la classe SWTBotTestCase. Enfin les méthodes assertXXX() (comme dans Junit) nous permettrons de tester l'état de nos composants graphiques.
Voici un exemple qui permet de s'assurer que tous les composants graphiques de l'interface sont bien présents et actifs. Notez la manière de récupérer une référence sur l'objet graphique via bot.

public void testPresence() throws Exception{
    assertNotNull(bot.activeShell());
    assertEnabled(bot.text(""));
    assertEnabled(bot.button("Envoi"));
}

Ici un autre exemple qui permet de dérouler un scénario fonctionnel, l'envoi d'un message via l'IHM de tchat, et de s'assurer une fois le message envoyé que la zone de saisie est bien vide.

public void testEnvoi() throws Exception{
    SWTBotText txt = bot.text("");
    txt.setText("Bonjour à tous");
    bot.button("Envoi").click();
    assertEquals("", txt.getText());
}

Exécution du test

Dans Eclipse l'exécution du test sera identique à celle d'un test JUnit, c'est à dire via le menu run... Notez tout de même qu'en mode debug, les méthodes pour récupérer une référence sur un objet graphique ne fonctionnent pas, cela vient probablement de la gestion des threads (ce point reste à élucider). Dernière remarque, si vous écrivez plusieurs classe de tests, il serait bon de les regrouper dans une TestSuite de manière à ne démarrer qu'une seule fois l'application.
Tout le code est en pièce jointe.