CoffeeBean

Présentation Play au Togo JUG : les slides

2012-01-28T15:42:00.001+01:00

Philippe et moi avons eu le plaisir de faire une présentation sur Play Framework (en versions 1.x et 2.0) pour le Togo JUG ce matin.

Les slides (présentation du framework, tutoriels...) sont disponibles ici : http://3monkeys.github.com/prez.play/

Note : pour les visionner il vaut mieux utiliser un navigateur sous WebKit, par exemple Chrome ou Safari.

Premiers pas avec Scalatra

2011-12-25T11:50:00.001+01:00

Scalatra est un framework Web ultra léger pour le langage Scala inspiré par Sinatra, un framework très populaire dans le monde Ruby.

Scalatra privilégie une approche très simple basée sur les principes REST. Pour effectuer une action, on part d'une méthode HTTP et d'une route (URL d'accès à la fonction), auxquelles on ajoute le traitement désiré :

get("/hello") {
    "hello!"
}

Avec cette approche et la manipulation XML proposée en Scala, on peut déclarer et renvoyer du contenu comme ceci :

get("/hello") {
  <html>
      <body>
        <h1>Hello!</h1>
     </body>
   </html>
}

On peut facilement ajouter des paramètres dans l'URL :

get("/hello/:name") { 
    <html>
      <body>
        <h1>Hello {params("name")} !</h1>
      </body>
    </html>
  }

Renvoyer du contenu XML (ou JSON ou ce qu'on veut) pour exposer un service REST :

get("/persons"){
 contentType="application/xml"
 <xml>
     <persons>{
         Database.entries.map { 
                    entry =>  <person>{entry}</person> 
                }
     }</persons>
 </xml> 
 }

Faire un POST pour enregistrer de nouvelles données :

post("/person"){
 val name = params("name")
 Database.addEntry(name)
 redirect("/persons")
  }

Remarque : Pour tester la méthode ci-dessus, on peut par exemple utiliser curl en ligne de commande :

curl for test: curl --data "name=jim" http://localhost:8080/person

On peut aussi rediriger l'action vers un template :

 get("/hello2/:name") {
      templateEngine.layout("hello-scalate.scaml", Map("name" -> params("name")))
  }

Scalatra est livré par défaut avec le moteur de template Scalate, qui est compatible avec plusieurs formats de templates. Voici un exemple avec le format scaml :

//redefinition du titre dans le layout par défaut
- attributes("title") 
//paramètre de requête
-@ val name: String

%h1 Welcome!
%p Hello, how are you #{name} ?

Enfin, on peut définir les actions à effecter en cas d'erreur :

notFound {
    
      
        
Nothing found here

      
    
  }

Le framework fonctionne avec l'outil de build SBT. Un support des WebSockets est proposé à travers la librairie Socket.IO. En utilisant Jetty, le conteneur par défaut de Scalatra, on peut recharger le code à chaud (plus ou moins rapidement). Pour cela on le démarre avec la commande suivante :

 sbt
 > container:start
   > ~ aux-compile

Dans cet exemple, j'ai simulé à la base de données avec un "object" Scala. Un object est l'équivalent d'un singleton : c'est une classe qui possède une instance unique.

object Database{
 //shared entries (simulate database)
 var entries = List("bob", "joe", "john") 
 def addEntry(name: String){
     entries = entries:+name
 }
}

On pourra facilement remplacer cette implémentation par une vraie base de données. Si vous n'avez pas besoin d'une base SQL (ce qui est en fait souvent le cas), vous pouvez regarder des choses plus simples comme la base de données objet NeoDatis qui supporte officiellement Scala. Pour des besoins de scalabilité plus importants, vous pouvez aussi jeter un oeil du côté de MongoDB et de Casbah (son toolkit Scala). Avec ce genre d'outils vous conserverez une architecture simple, pas besoin de s'embêter avec des frameworks à la Spring, le langage apporte tout ce qu'il faut pour gérer l'injection de dépendance nativement. Pour conclure, Scalatra nous prouve que contrairement aux idées reçues, on peut faire des choses extrêmement simples et efficaces en Scala avec des API bien pensées. Si vous cherchez quelque chose s'en rapprochant et utilisant le langage Java, vous pouvez regarder du côté de Spark.
Et puis j'allais oublier, joyeux Noël à tous!

Site officiel de Scalatra

Stateful VS Stateless : une mise en bouche du débat

2011-11-16T11:04:00.001+01:00

Philippe Charrière, Antoine Sabot-Durant et moi avons eu l’honneur d'être interviewés par les JDuchess pour présenter le sujet de la prochaine conférence du Lyon JUG : Architecture stateful vs stateless (que nous animerons mardi prochain)

Cette première partie du débat est à lire ici

Présentation Stateful VS Stateless au Lyon JUG le 22 Novembre

2011-11-12T19:03:00.001+01:00

Le mardi 22 Novembre j'aurai l'honneur d'animer une session sur le thème des architectures stateless avec Philippe Charrière. Nous présenterons ce concept à travers une démo basée sur Play Framework.

Nous confronterons notre vision à celle d'Antoine Sabot-Durant qui présentera l'alternative stateful avec Java EE (CDI, EJB 3...).

Pour vous inscrire à cette présentation, c'est ici : http://www.lyonjug.org/evenements/architecture-stateful-vs-stateless

Un nouveau site pour Play.Rules!

2011-10-06T12:00:00.001+02:00

Mon coéquipier Philippe (aussi connu sous le pseudo @k33g_org) vient de mettre en ligne un superbe site Web pour notre ebook Play.Rules!

Ce site permet de consulter en ligne les différents chapitres.
Il nous servira aussi à publier les news concernant le livre et son avancement.

Voici donc une URL à bookmarker ;) http://3monkeys.github.com/play.rules/

Pour ce qui est des nouveaux chapitres, on est pas mal occupés en ce moment mais du contenu supplémentaire ne devrait pas tarder à se montrer!

Play Framework Cookbook

2011-09-25T18:33:00.000+02:00

J'ai eu la chance de recevoir un exemplaire gratuit du livre Play Framework Cookbook de la part de Packt en échange d'une critique sur ce blog. Je vais donc essayer de vous donner mon avis tout en restant le plus objectif possible.

Après un premier chapitre qui présente toutes les opérations courantes d’un projet Play (création de vues, modèles, routes, gestion de la session utilisateur...), le livre se focalise sur un ensemble d’astuces répondant à des cas concrets. On trouve par exemple des chapitres traitant de (au hasard et dans le désordre) :

la configuration des routes par annotations
le caching
la génération de fichiers PDF ou de graphiques avec Google Chart API
l’injection de beans Spring ou Guice

Le livre explique en détail les principes de la création de modules Play et donne des exemples d’utilisation de modules existants, comme la connexion à une base NoSQL à l’aide du module MongoDB.
Si on devait résumer le style d’écriture, ce serait “beaucoup de code et peu de blala”.
Pour chaque partie on retrouve les mêmes sections : getting ready, how to do it, how it works, there is more.
Cette structure permet de comprendre en détail le fonctionnement des différentes briques du framework. La dernière de ces 3 parties a un rôle d’ouverture, on y trouve des conseils pour améliorer notre code ou pour booster les perfs ainsi que des solutions alternatives en s’appuyant par exemple sur des librairies externes.

Le livre ne s’arrête pas au développement d’une application Play. Il présente un certain nombre d’astuces pour la mise en production (comme la mise en place d’un load balancer), l’intégration continue (avec jenkins), la gestion des logs ou encore le paramétrage d’un repository de modules privé.
Vous l'aurez compris, il couvre donc un scope d’astuces assez large. Ce livre ne demande pas forcément une lecture linéaire : on peut facilement sauter des chapitres pour aller directement chercher l’exemple qui répondra à notre problème du moment.

Si on devait trouver quelques petits manques ou défauts, aucune plateforme de cloud n’est présentée. Le livre a été écrit trop tôt pour parler du PaaS Heroku, cependant les modules CloudBees et Google APP Engine existent depuis un certain temps et auraient pu être abordés. Pas de Scala non plus, mais il est vrai cela demanderait presque un deuxième livre, l’API Play Scala étant vraiment différente de la version Java (ceci devrait changer avec Play 2.0).
Enfin, le livre s'adresse plutôt aux personnes qui connaissent les bases de Play et qui veulent des recettes pour répondre a des problèmes précis. Cette démarche va assez loin puisque le livre comprend même une partie dédiée à l’optimisation de byte code. En ce sens, le tutoriel YABE de la documentation officielle ou le livre Play.Rules (pub perso ;) seront sûrement des pistes à privilégier pour les novices.
Cet ouvrage sera par contre une mine d’or pour les développeurs qui se lancent dans un projet “real life” et qui cherchent un vrai cookbook avec des techniques applicables au quotidien. Et comme je suis sympa je vous offre un chapitre gratuit!

Heroku offre un PaaS pour Play Framework

2011-08-29T19:06:00.000+02:00

Bonne nouvelle les amis, la plateforme de Cloud Heroku, particulièrement célèbre dans le monde Ruby, vient d'annoncer un support natif des application Play Framework!

Nous avons donc à notre disposition un PaaS pour notre (ou du moins mon) framework préféré, permettant de déployer une application en production en une ligne commande (via Git).
De plus, en dessous d'un certaine nombre d'un certain nombre de connexions le service est gratuit.
Et si votre application rencontre le succès que vous espériez, vous pourrez alors passer sur du payant avec une configuration un peu plus costaud et bénéficier de toute la scalabilité offerte par la plateforme.

Tout ça pour vous dire que je pensais justement faire un chapitre dans l'eBook play!rules sur le déploiement d'une application dans le Cloud... Heroku étant la première plateforme à supporter Play nativement, je vais naturellement m'orienter vers cette solution. So stay tuned, le chapitre devrait arriver très rapidement.

Ps : merci à Nicolas du Touilleur Express qui a tweeté cette information hyper vite comme toujours!

MAJ : Le (très court) chapitre sur Heroku est maintenant disponible ici.

Kotlin: un nouveau langage pour la JVM

2011-07-20T12:12:00.009+02:00

JetBrains (l'éditeur de l'excellent IDE IntelliJ IDEA) vient d'annoncer qu'ils lançaient leur propre langage pour la JVM : Kotlin.
Cette annonce arrive quelques mois après celle de Red Hat qui a presénté le langage Ceylon au mois d'Avril.

Alors à quoi ressemble ce nouveau langage? Pour faire court, prenez Scala, rendez le un peu plus abordable et facile d'accès, ajoutez y un peu de Groovy et quelques nouvelles features.

Vous comprendrez mieux avec quelques exemples de code .

On peut facilement écrire ce genre de code grâce aux expressions lambda :

names filter {it.startsWith("A")} map {it.toUpperCase()} foreach {print(it)}

Ce code écrit en majuscule dans la console tous les nom commençant par A.
C'est le genre de choses toutes simples qui peuvent être vraiment lourdes à écrire en Java...

On peut également faire du pattern matching à la Scala :

fun cases(obj : Any) {
  when(obj) {
    1          => print("One")
    "Hello"    => print("Greeting")
    is Long    => print("Long")
    !is String => print("Not a string")
    else       => print("Unknown") 
  }
}

Kotlin est un langage à typage statique. Mais il propose un mécanisme d'inférence de type pour alléger la syntaxe :

var a : Int = 1
var b = 1 // Type inféré

On peut même automatiser les cast dans certains cas :

if (obj is String) 
    return obj.length // pas de cast explicite

Le langage fournit un système de properties très bien pensé (pour éviter d'écrire les getters et setters à la main), qui rappelle un peu celui de C#.

La gestion des null est aussi très efficace et devrait résoudre pas mal de problèmes liés au null pointers. Un champ ne peut être null que si on l'autorise :

var a : String = "abc"
a = null // erreur de compilation

var b : String? = "abc"
b = null // ok

Pour y accéder, on fait comme en Groovy :

b?.length()

Ceci renverra length() si b est non null, rien sinon. On pourra donc éviter quelques fastidieux if(b!=null) dans notre code.

Pour réduire le risque d'erreurs, l'utilisation du "?" est obligatoire pour accéder aux objets "nullables" :

b.length() //erreur de compilation

Enfin, le langage offre la même sécurité que Scala au niveau de l'immutabilité, avec l'usage du mot clé "val" (au lieu de "var") pour déclarer une propriété immuable. Ceci aura aussi une incidence sur la génération automatique des accesseurs : seul un getter est généré pour une propriété de type val.

Si cette mise en bouche vous a ouvert l'appétit, je vous conseille de regarder ces exemples plus détaillés sur le site du langage.

En tout cas personnellement je trouve ça très prometteur. Le support natif dans IntelliJ IDEA sera un gros plus des son lancement. J'espère sincèrement que ce langage aura sa chance dans la jungle des langages pour la JVM!

MAJ : Vous pouvez dès à présent jouer avec la Web demo de Kotlin

Play!Rules: un chapitre sur Play et Scala

2011-06-24T22:34:00.000+02:00

Un nouveau chapitre est disponible dans l'ebook gratuit (et open source) Play!Rules, il explique comment développer avec Play Framework et le langage Scala .

Pour en savoir plus, ça se passe ici.

Spring Data JPA et Querydsl

2011-05-28T10:50:00.021+02:00

SpringSource a récemment lancé le projet Spring-Data, un ensemble de sous projets ayant pour but de nous aider à manipuler plus facilement nos données.

Nous allons nous attarder sur Spring-Data-JPA, qui fournit un ensemble d'automatisations pour JPA.

Repositories

Les repositories sont des interfaces pour lesquelles nous n'avons pas à fournir d'implémentation. Ces interfaces seront implémentées par le framework lui même au démarrage du contexte Spring.

On considère la classe Person :

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String firstName;
    private String lastName;
    private Integer age;
    private String city;
 //getters & setters 
}

Si on écrit par exemple :

public interface PersonRepository extends JpaRepository<Person, Long> {
    List<Person> findByCity(String city);    
}

Spring implémentera une requête en se basant sur le nom de la méthode, pour rechercher des personnes par la ville où elles habitent.

Pour utiliser plusieurs paramètres on utilise le mot clé "And" :

List<Person> findByFirstNameAndLastName(String firstName, String lastName);

On peut utiliser tout un tas d'autres mots clés dans le nom des méthodes pour construire nos requêtes :

And
Or
GreaterThan
LessThan
Like
IsNull
OrderBy
...

Par exemple :

List<Person> findByAgeOrderByLastnameDesc(Integer age);

Les repositories permettent aussi de persister les entités dans la base :

personRepository.save(person);

Ces fonctionnalités sont directement reprises depuis Hades, les 2 frameworks partageant le même spec leader.

Si on veut écrire directement une requête JPQL, on peut utiliser l'annotation @Query :

@Query("ma super requête ici")
List<Person> findWithMyCustomQuery(Customer customer);

La requête sera exécutée lorsque qu'on appellera la méthode findWithMyCustomQuery.

Named queries

Pour utiliser une NamedQuery, il suffit que le nom de la méthode du repository suive le même nom que la NamedQuery. Dans ce cas de figure, le framework n'essaiera pas de générer une requête en suivant le nom de la méthode.
Par exemple la méthode findByNameWithMyFilters sera mappée sur la requête nommée "Person.findByNameWithMyFilters".

Entité :

@Entity
@NamedQuery(name = "Person.findByNameWithMyFilters", 
  query = "select p from Person p where filter1 = ? and filter2 = ?")
public class Person {...}

Repository :

Person findByNameWithMyFilters(String filter1, String filter2);

Ces repositories nous facilitent bien la vie en générant pour nous les requêtes pour un grand nombre de cas courants. Un détail qui a son importance : toutes les méthodes des repositories sont transactionnelles par défaut.

Querydsl

Querydsl est une librairie qui apporte des API pour requêter des entités de manière "typesafe" et avec une syntaxe épurée. Spring-Data supporte cette librairie pour simplifier l'écriture de prédicats en Java.

Voici quelques exemples de requêtes, avec l'utilisation des mots clés eq (equals), like et gt (greater than) :

private static QPerson person = QPerson.person;

public static BooleanExpression fromCity(String city) {
 return person.city.like(city);
}

public static BooleanExpression byName(String firstName, String lastName) {
 return person.firstName.eq(firstName).and(person.lastName.eq(lastName));
}

public static BooleanExpression adults() {
 return person.age.gt(18);
}

J'aime beaucoup cette syntaxe, elle est vraiment fluide, facile à écrire et lisible. Il est bien sur possible de gérer des cas plus complexes, je vous laisse consulter la doc de Querydsl pour en savoir plus.

Pour exécuter une requête utilisant un de ces prédicats, il suffit d'écrire :

personRepository.findAll(Person.fromCity("maVille"))

personRepository.findAll(Person.adults())

Pour que tout cela fonctionne, notre repository doit implémenter QuerydslPredicateExecutor. On doit également définir ce plugin dans le build maven, qui se chargera des générer les classes Q* pour chacune des entités du projet :

<plugin>
        <groupId>com.mysema.maven</groupId>
      <artifactId>maven-apt-plugin</artifactId>
      <version>1.0</version>
      <executions>
          <execution>
              <phase>generate-sources</phase>
              <goals>
                  <goal>process</goal>
              </goals>
              <configuration>
                  <outputDirectory>target/generated-sources</outputDirectory>
                  <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
              </configuration>
          </execution>
      </executions>
  </plugin>

N.B : Il est possible d'écrire nos prédicats avec l'api criteria de JPA 2 au lieu de Querydsl si on le souhaite, en utilisant la classe org.springframework.data.jpa.domain.Specification à la place de nos BooleanExpression.

Voyons comment utiliser nos repositories et nos prédicats :

@Test
  public void testPersistence() {

      Person p = new Person();
      p.setFirstName("loic");
      p.setLastName("descotte");
      p.setCity("Grenoble");
      p.setAge(29);

      Person p2 = new Person();
      p2.setFirstName("john");
      p2.setLastName("doe");
      p2.setAge(17);
      p2.setCity("NYC");

      //save
      personRepository.save(p);
      personRepository.save(p2);

      persons = personRepository.findAll();
      assertEquals(persons.size(),2);

      persons = (List) personRepository.findAll(Person.fromCity("%Gre%"));
      assertEquals(persons.size(),1);
      assertEquals(persons.get(0).getFirstName(),"loic");

      persons = (List) personRepository.findByFirstNameAndLastName("loic", "descotte");
      assertEquals(persons.size(),1);
      assertEquals(persons.get(0).getCity(),"Grenoble");

      persons = (List) personRepository.findAll(Person.adults());
      assertEquals(persons.size(),1);
      assertEquals(persons.get(0).getFirstName(),"loic");
  }

Dans cet exemple le code client est une classe de test, mais on peut très bien appeler notre repository depuis un service REST, depuis la couche graphique, etc. (voir le code source de l'exemple en téléchargement à la fin de cet article).

On voit dans ces exemples qu'on a complètement modifié notre façon d'architecturer notre application Spring: on peut si on le souhaite se passer des couche "services" ou "business" qui contiennent habituellement la logique de notre application.
En effet Spring-Data et ses repositories ont un bon gout de DDD (Domain Driven Design). Ceux qui ont essayé Play connaissent déjà cette approche.
Le code métier de notre application peut être recentré sur le modèle (objets du domaine métier). A nous la vrai conception objet, fini les modèles anémiques sans intelligence dont les seules méthodes sont des getters et des setters.
Comme vous le voyez dans cet exemple, on a même la possibilité de placer nos prédicats d'accès à la base de données dans la classe Personne.

Pour conclure ce nouveau framework est vraiment prometteur et apporte pas mal de nouveautés et de facilités aux applications codées en environnement Spring.
Le seul bémol que j'ai vu étant (comme souvent avec Spring et Maven) le temps nécessaire pour mettre au point la configuration XML et trouver les bonnes dépendances (sans compter les conflits avec Jersey, etc.)
Mais comme je suis sympa vous pouvez tout recopier dans le code source des exemples de l'article : code source de l'exemple.

Je vous conseille de jeter également un oeil aux autres projets de Spring-Data, tout aussi intéressants et qui adressent le monde NoSQL (bases orientées graphes, documents, clé/valeur...).

WebSocket et Play Framework

2011-05-22T16:33:00.002+02:00

Vous avez surement entendu parler de WebSocket, un (futur) standard HTML 5 qui permet de faire du push de données du serveur vers le navigateur.
L'utilisation des WebSockets est très simple avec Play et très utile dans le cas de traitements asynchrones.

Vous pouvez lire ce nouveau chapitre dédié à WebSocket sur l'ebook play.rules : https://github.com/3monkeys/play.rules/blob/master/livre/part01-je-suis-pret/ch05-jobs-et-traitements-asynchrones.md (deuxième partie du fichier).

Comme d'habitude n'hésitez pas à envoyer vos remarques si des éléments ne sont pas clairs ou si vous trouvez des fautes :)

Du Play et du Scala!

2011-04-12T19:25:00.001+02:00

Je suis entrain de réécrire entièrement en Scala mon application de démo pour Play framework!
Le code de l'application est disponible ici : https://github.com/loicdescotte/vote4music-scala
Une occasion de comparer les langages, puisque la version Java est disponible là : https://github.com/loicdescotte/vote4music

Personnellement je trouve l'API Scala de Play plutôt bien pensée, elle colle même peut être encore plus à l'esprit Play que la version Java. On gagne en concision et surtout en expressivité du code grâce à l'approche fonctionnelle.

Le code de l'application n'est pas encore parfait, il reste quelques bugs et quelques TODO (les API Json et XML ne sont par exemple pas encore fonctionnelles). Mais la plupart des fonctionnalités sont là.

Cette version Scala fera d'ailleurs l'objet d'un chapitre dans le livre Play.rules dont je vous ai parlé dans le post précédent.

Pourquoi Play + Ebook gratuit et open source!

2011-04-10T12:48:00.003+02:00

Sur ce blog il m'est souvent arrivé de vous parler de Play Framework.
Aujourd'hui revenons un peu au début de l'histoire, je vais vous présenter les raisons pour lesquelles j'aime autant Play.

J'ai décris toutes ces raisons ici (suivez le lien)

En fait ceci n'est que le premier chapitre d'un Ebook gratuit, open source et collaboratif sur lequel je travaille avec mes 2 amis @k33g_org et @mklabs! Notre but est de fournir un livre convivial, facile à lire et avec un ton un peu différent de ce qu'on trouve dans la littérature habituelle. L'aspect open source donnera, je l'espère, l'envie à des personnes de nous aider pour les relectures ou de contribuer à des chapitres!

On en est qu'a tout début, il reste encore beaucoup à écrire. Mais on avance à bon rythme et petit à petit le livre devrait se remplir! Vous pouvez déjà le consulter librement sur GitHub : https://github.com/3monkeys/play.rules

Présentation du langage Scala par Aleksandar Prokopec de l'EPFL

2011-03-25T14:21:00.000+01:00

Lundi dernier nous avons eu le plaisir d'accueillir à l'Alpes JUG Aleksandar Prokopec, un des contributeurs de Scala, le langage orienté objet et fonctionnel pour la JVM dont tout le monde parle en ce moment.

Les slides et le compte rendu de la présentation sont disponible ici.

Mix-IT : le rendez vous Java et agilité en Rhône Alpes

2011-03-15T21:07:00.002+01:00

Mix-IT est un événement organisé par le Lyon JUG et le CARA (Club Agile Rhône Alpes).
Durant toute la journée du 5 avril nous aurons l’occasion de suivre des conférences autour de 5 thèmes : Techy, Agility, Mixy , Trendy et Gamy.

Avec des célébrités du paysage IT français comme Nicolas Martignole (rédacteur du blog Le Touilleur Express), Mathilde Lemee (java-freelance) et bien d’autres, choisir les sessions de conférences ne sera pas une tâche aisée.

En plus le prix est vraiment abordable pour ce genre de conférence : 20 € pour la journée complète, repas inclus. Un événement à ne pas rater pour tous les geeks de la région Rhône Alpes, et même les autres !

Le programme complet

Le site officiel

Validation HTML5 et Play!

2011-02-26T12:03:00.006+01:00

La spécification HTML 5 prévoit la possibilité de valider les données d'un formulaire HTML côté client, directement dans le navigateur avant d'envoyer les données vers un serveur.
Il existe un module pour Play! qui permet de faire un mapping entre les annotations de validation du modèle (qui servent normalement à valider les données côté serveur) et le rendu HTML, pour intégrer cette fonctionnalité.

Pour activer ce module, après l'avoir téléchargé il suffit d'ajouter cette ligne dans le fichier application.conf :

module.html5validation=modules/html5validation

Sur une entité du modèle, on ajoute une annotation de validation pour indiquer qu'un des champs est obligatoire :

@Entity
public class Album extends Model {

    @Required
    public String name;
}

Dans le formulaire HTML, on peut utiliser un nouveau tag, #{input} :

#{input for:'album.name', type:'text', id:'name' /}

Ce tag sera traduit en une balise input classique, avec un attribut indiquant que le champ est obligatoire :

<input type="text" name="album.name" value="album?.name" id="name" required="required"/>

Le rendu est le suivant si on valide le formulaire sans remplir le champ obligatoire :

Le tag input supporte un grand nombre d'options et plusieurs types d'annotations de validation, comme @Match pour valider une expression régulière ou @Email. Toutes ces options sont décrites dans cette documentation.

Si votre navigateur ne supporte pas la validation HTML5, aucun soucis car la validation côté serveur sera exécutée dans tous les cas. J'ai testé avec Chrome 10 et Firefox 4 beta 12 et cela fonctionne parfaitement sur ces navigateurs.

Première appli GWT avec UiBinder et GWT Designer

2011-02-17T13:44:00.013+01:00

Dans ce tutoriel nous allons voir comment développer facilement une petite application de gestion de taches à l’aide de GWT, UiBinder et GWT Designer.

GWT Designer est un outil de création d’interfaces graphiques qui fonctionne en drag and drop, à la manière du designer SWING Matisse de Netbeans.

UI Binder est une nouvelle façon de décrire les interfaces graphiques GWT. Avec ce framework on déclare les IHM en XML et non en Java comme on le faisait dans les versions anterieures de GWT. Le code est ainsi plus concis et beaucoup plus lisible.
Dans ses dernières versions, GWT Designer est compatible avec UiBinder.

Installation de l’outillage

Google fournit un plugin Eclipse plutôt bien fait qui apporte le support de GWT et de Google APP engine. Depuis la version 2.2 qui vient de sortir cette semaine, le plugin contient également GWT Designer.

Pour installer ce plugin sous Eclipse Helios (3.6), ajoutez ce repository : http://dl.google.com/eclipse/plugin/3.6

Création du projet
Après avoir installé le plugin, créez un nouveau projet en cliquant sur le bouton

Une première page d’exemple sera générée. Vous constaterez au passage que le générateur de projets n’utilise pas encore UI Binder et que le code java ressemble grossièrement à du SWING.
Nous allons voir comment faire quelque chose de plus élégant avec cette version de GWT.

Création d’une IHM
Dans le menu du projet, cliquez sur New-> UiBinder
Puis créez une classe nommée TodoList.

GWT nous génère alors une classe Java qui permettra de traiter les évènements et un fichier XML pour décrire l'interface graphique. Une fois compilé, tout ce code sera transformé en HTML et en JavaScript pour être exécuté sur un navigateur.

Nous allons dessiner notre panel comme ceci :

On a maintenant un petit formulaire (2 champs texte et “datebox”) pour ajouter des taches et un tableau pour les afficher.

Le code généré côté XML est le suivant :

<g:HTMLPanel>
 <g:FlowPanel>
   <g:Label text="Add a new task" width="100%" height="100%" styleName="{style.big}"/>
   <g:Label text="Name"/>
   <g:TextBox ui:field="nameField"/>
   <g:Label text="Description"/>
   <g:TextBox ui:field="descriptionField"/>
   <g:Label text="Due Date"/>
   <p2:DateBox ui:field="dateField"/>
  </g:FlowPanel>
  
  
  <g:SimplePanel>
  <g:Button ui:field="button">Save</g:Button>
  </g:SimplePanel>
  
  <div id="todolist">
  <g:FlowPanel>
   <g:Label text="What you have to do" width="100%" height="100%" styleName="{style.big}"/>
   <p1:CellTable ui:field="todoTable"/>
  </g:FlowPanel>
  </div>
  
 </g:HTMLPanel>

C’est un mélange de HTML et de balises spécifiques à GWT.

Revenons à notre designer. Si on selectionne un champ, on peut renseigner la variable “UiField” dans la zone “Properties”. Lorsqu’on renseigne cette variable, un champ est créé dans la classe Java correspondant à notre composant graphique. On peut ensuite manipuler ce champ depuis le code, par exemple pour changer la valeur d’un label lors d’un évenement de clic.

Interception d’un évenement

Lors d’un clic sur le bouton Save, on peut déclencer l’enregistrement d’une tache :

@UiHandler("button")
 void onButtonClick(ClickEvent event) {
  //evenement ici 
 }

Il est possible de générer ce bout de code depuis GWT Designer en effectuant un clic droit sur le bouton Save puis en sélectionnant Add event handler -> onClick
Nous verrons dans la suite de l'article le détail de cette méthode.

Création d’un service asynchrone
Nous allons créer un service côté serveur qui sera appelé de manière asynchrone par le client GWT.
Dans le menu du projet, cliquez sur New-> GWT RemoteService
Créez ensuite une classe nommée TodoService.

Le plugin va générer une interface TodoService et une classe TodoServiceImpl.

Rajoutons ces méthodes dans l’interface :

List<Todo> getTodos();
 List<Todo> addTodo(Todo todo);

Nous avons donc une méthode pour récupérer les taches existantes et une autre pour en créer de nouvelles.
Le plugin propose de générer une interface jumelle de TodoService, TodoServiceAsync qui prend en compte l’aspect asynchrone des appels. C’est cette interface que nous appellerons depuis la gestion d'évènements des widgets GWT.

Nous pouvons à présent coder la partie implémentation du service :
On y ajoute le code suivant :

//This is a mock for the Database
private List<Todo> todos = Arrays.asList(new Todo("truc1", "un truc", new Date()),new Todo("truc2", "un autre truc", new Date()));
 
 @Override
 public List<Todo> getTodos() {
  return todos;
 }

 @Override
 public List<Todo> addTodo(Todo todo) {
  todos = new ArrayList<Todo>(todos);
  todos.add(todo);
  Collections.sort(todos);
  return todos;
 }

La liste “todos” permet simplement de simuler une base de données pour simplifier cet exemple.

Paramétrage du tableau de données

Retournons maintenant côté client, pour paramétrer la manière dont le tableau va afficher les données en appelant le service.
On ajoute ce code dans le constructeur de la classe TodoList :

provider = new AsyncDataProvider<Todo>() {

   @Override
   protected void onRangeChanged(HasData<Todo> display) {
    todoService.getTodos(new AsyncCallback<List<Todo>>() {

     @Override
     public void onFailure(Throwable caught) {
      caught.printStackTrace();
     }

     @Override
     public void onSuccess(List<Todo> result) {
      updateRowData(0, result);
      
     }
    });
    
   }
  };
  provider.addDataDisplay(todoTable);
  
  TextColumn<Todo> todoNameColumn = new TextColumn<Todo>() {

   @Override
   public String getValue(Todo todo) {
    return todo.getName();
   }
  };
  
  TextColumn<Todo> todoDescriptionColumn = new TextColumn<Todo>() {

   @Override
   public String getValue(Todo todo) {
    return todo.getDescription();
   }
  };
  
  TextColumn<Todo> todoDateColumn = new TextColumn<Todo>() {

   @Override
   public String getValue(Todo todo) {
    DateTimeFormat fmt = DateTimeFormat.getFormat("dd/MM/yyyy");
    return fmt.format(todo.getDate());
   }
   
  };
  
  todoTable.addColumn(todoNameColumn, "Name");
  todoTable.addColumn(todoDescriptionColumn, "Description");
  todoTable.addColumn(todoDateColumn, "Due date");

On a ajouté 3 colonnes qui correspondent aux informations que l'on peut rentrer dans le formulaire.

L'objet provider permet de charger la liste des taches en appelant notre service asynchrone.
En cas de succès on charge tous les objets à partir du rang 0 (on ne gère pas la pagination dans cet exemple).

Appeler le service depuis un clic bouton

Nous pouvons maintenant compléter l'évènement que nous avons associé à notre bouton :

@UiHandler("button")
 void onButtonClick(ClickEvent event) {
  if (!nameField.getText().equals("")){
  Todo todo = new Todo(nameField.getText(), descriptionField.getText(),dateField.getValue());
  todoService.addTodo(todo, new AsyncCallback<List<Todo>>() {
   
   @Override
   public void onSuccess(List<Todo> result) {
    provider.updateRowData(0, result);
   }
   
   @Override
   public void onFailure(Throwable caught) {
    caught.printStackTrace();
   }
  });
  }
 }

Un clic sur le bouton appelle le service pour ajouter une tache et recharge le tableau à partir du résultat obtenu, en appelant la méthode updateRowData.

Pour terminer, nous allons modifier la page principale de l'application GWT pour y ajouter la liste de taches:

/**
  * This is the entry point method.
  */
 public void onModuleLoad() {

  RootPanel.get().add(new TodoList());
  
 }

Et voilà, notre mini appli est fonctionnelle! En conclusion on peut dire qu'avec cet outillage on obtient quelque chose de comparable à l'environnement de développement Flex, mais avec pour cible des applications HTML 5 au lieu de reposer sur la plateforme Flash. Et tout ça en gardant les outils de développement que l'on a dans le monde Java. A ce propos je vous conseille de tester les capacités de debug de GWT, c'est assez bluffant : le framework permet d'intercepter dans le code Java les évènements qui sont en fait exécutés côté client en JavaScript! On peut alors analyser les variables comme si on était entrain de debugger du pur Java. C'est aussi là qu'on voit la puissance de GWT.

Pour télécharger le code source cliquez ici
Pour savoir comment déployer cette application dans le cloud sur Google App Engine vous pouvez regarder ce post

How to export objects as JSON with Play framework

2011-01-19T18:20:00.007+01:00

With Play, it is extremely easy to create a REST service that exposes some model objects in JSON format.

If we write this line in the routes file :

GET /albums.json            Application.listAlbumsInJson

And this method in the controller :

public static void listAlbumsInJson(){
        List<Album> albums = Album.findAll();
        renderJSON(albums);
    }

Calling http://myapp/albums.json URL will return the album list in JSON format. It could not be simpler!

Another trick (I discovered on zengularity.com website) : to determine the data format directly from the URL, it is possible to use this syntax in the routes file :

GET /albums.{<json|xml>format} Application.listAlbums

If we call /albums.xml , Play will call listAlbums() with the 'format' parameter set to 'xml', and calling /albums.json will set the same parameter to 'json'.

We can use it in the controller :

public static void listAlbums() {
               List<Album> albums = Album.all().fetch();
         if(request.format.equals("json"))
            renderJSON(albums);
         else render(albums);
    }

If you reach /albums.xml, Play will look for an XML template file named listAlbums.xml (an other file extension would work too).

For more information about writing REST (and XML) API with Play, you can read this post.
I also updated my Play sample application by adding some JSON services.

Play framework : exporter ses objets en JSON

2011-01-19T11:19:00.010+01:00

Avec Play il est extrêmement facile de créer un service REST qui expose les objets du modèle au format JSON.

Si on écrit cette ligne dans le fichier routes :

GET /albums.json            Application.listAlbumsInJson

Et cette méthode dans le contrôleur :

public static void listAlbumsInJson(){
        List<Album> albums = Album.findAll();
        renderJSON(albums);
    }

L'appel de l'URL http://monappli/albums.json renverra directement notre liste d'objets albums au format JSON. Difficile de faire plus simple!

Autre astuce (que j'ai découvert grâce site zengularity.com) : pour déterminer directement le format de données à partir de l'URL, il est possible d'utiliser cette syntaxe dans le fichier routes :

GET /albums.{<json|xml>format} Application.listAlbums

En appelant /albums.xml , Play appelera la méthode listAlbums() avec le paramètre 'format' initialisé à 'xml', et en appelant /albums.json ce même paramètre aura la valeur 'json'.

On peut ensuite s'en servir dans le contrôleur :

public static void listAlbums() {
               List<Album> albums = Album.all().fetch();
         if(request.format.equals("json"))
            renderJSON(albums);
         else render(albums);
    }

Si vous tapez l'URL /albums.xml, Play cherchera un fichier de template XML nommé listAlbums.xml (une autre extension fonctionnerait aussi) pour effectuer le rendu.

Pour en savoir plus sur l'écriture de services REST avec Play (notamment sur les templates XML) vous pouvez consulter cet article.
J'ai également mis à jour mon application d'exemple pour Play framework pour exposer des services en JSON en plus du XML.

[Hors série Musique] Rétrospective 2010

2011-01-10T19:15:00.009+01:00

Pour une fois je ne vais pas vous parler de Java ni même d'informatique, mais de musique (mon autre passion). Je vais essayer de revenir sur les albums qui m'ont le plus marqué durant l'année 2010. Il y aura du Rock, du Jazz, du Metal... Pas uniquement des albums sortis l'année dernière, mais aussi ceux que j'ai découvert ou re-découvert durant cette période et qui ont occupé le poste de ma voiture.

Porcupine Tree - Atlanta (Rock progressif - 2010)

Cet album live uniquement disponible en téléchargement a été lancé pour soutenir une oeuvre caritative. Enregistré durant la tournée de l'album Fear Of A Blank Planet (mon préféré), on y retrouve un certains nombre de classiques d'époques antérieures comme Dark Matter ou A Smart Kid. Mais la setlist est surtout orientée vers les derniers titres du groupe comme Anesthetize ou Let's sleep together, qui surpasse la version studio en y apportant une énergie supplémentaire. Le son et le jeu du groupe sont excellents. Gavin Harisson qui a reçu plusieurs "awards" pour ses performances à la batterie est impressionnant et apporte un groove indéniable aux prestations du groupe. Un futur classique pour les amateurs de rock progressif!

Télécharger l'album

The Ocean - Anthropocentric (Post Metal - 2010)
The Ocean nous a gratifié de deux albums en 2010. En fait il s'agit plutôt d'un concept album en 2 parties.
La première partie Heliocentric est beaucoup plus calme que ce que le groupe a l'habitude de nous proposer. Les ballades y sont nombreuses, les violoncelles et les pianos très présents. Un bon album mais qui a laissé le public un peu sur sa faim à cause de son côté parfois "mielleux". Heureusement la deuxième partie Anthropocentric a mis tout le monde d'accord avec une orientation bien plus sombre et agressive. Il faut dire que c'est dans ce registre que le groupe excelle vraiment. Le morceau titre annonce tout de suite la couleur avec une ambiance lourde et des passages plus calmes qui rappellent Opeth. La trilogie The Grand Inquisitor est tout simplement excellente. L'album cache même quelques trésors de musique atmosphérique et planante comme le morceau instrumental Wille Zum Untergang.

Ecouter sur myspace

Opeth - In Live Concert at the Royal Albert Hall (Metal progressif - 2010)

Reprenant une célèbre pochette de Deep Purple, cet album live a été enregistré pour l'anniversaire du groupe (20 ans déjà!). Il reprend l'intégralité de l'album BlackWater Park qui fêtait quand-à lui ses 10 ans. La deuxième partie de ce live retrace l'histoire du groupe et reprend un morceau de chacun de leurs albums, du plus ancien au plus récent.

Le son de ce live est excellent. Puissant et chaud. La sélection des titres est très bonne aussi, même si avec ce genre de formule on ne peut pas avoir toutes les chansons qu'on voudrait (un seul morceau pour l'album Deliverence c'est trop peu!!). Mais on a quand même 3 CD (et un DVD selon l'édition) donc on en a pour notre argent. Indispensable pour tout fan d'Opeth ou de Metal en général.

Ecouter sur Spotify

Anathema - Where the Light is (Rock progressif/atmosphérique - 2010)

Cet album d'Anathema était attendu depuis longtemps puisque leur dernier opus datait de 2003. En sept ans le style du groupe a évolué vers quelque chose de plus léger, plus planant. En effet les anglais qui nous avaient habitué à un rock sombre voire déprimant (mais néanmoins magnifique) semblent avoir repris gout à la vie. Ont-ils pour autant perdu leur identité? Pas du tout, ils nous livrent même un de leurs meilleurs albums. La patte de Steven Wilson (le leader de Porcupine Tree), qui a produit l'album, se fait sentir et ce n'est pas non plus pour me déplaire. En conclusion, un bel album à écouter pour se détendre, bien assis dans son canapé en rentrant du boulot.

Ecouter sur Deezer

Avenged Sevenfold - Nightmare

Je ne connaissais pas du tout ce groupe avant d'apprendre que Mike Portnoy, ex-Dream Theater, avait enregistré leur dernier album pour remplacer leur défunt batteur . Visiblement ce groupe est soit adoré, soit détesté pour le côté "mainstream" de leur musique, et aussi parce-qu'ils ont eu un certains succès auprès des adolescents au début de leur carrière.

Ce groupe qui fait maintenant du Heavy Metal a commencé par un style plus proche du Hardcore. Leur musique, bien que résolument Heavy dans cet album, a encore quelques sonorités qui peuvent rappeler cette époque. Moi qui déteste le punk et le "teenage rock" au plus haut point, je dois dire cet aspect ne m'a finalement pas dérangé. Le groupe joue avec une énergie débordante, l'influence des grands du Heavy Metal, et tout particulièrement de Metallica, se fait sentir tout au long du disque. Techniquement les musiciens sont au top, un travail énorme est fait sur l'harmonisation des guitares.
Pour agrémenter le tout, la voix du chanteur est excellente, entre celle d'Axl Rose et celle de James Hetfield. Ajoutez à tout ça des riffs super puissants (à la Metallica encore une fois), des solos de virtuose et des refrains vraiment accrocheurs, presque FM (d'où des critiques par certains metaleux pur souche) et vous obtiendrez des morceaux qui vous resteront dans la tête un bon moment!

Ecouter sur Spotify

Demians - Mute (Rock progressif - 2010)

Le premier français de cette rétrospective. Nicolas Chapel, chanteur et multi instrumentiste a réalisé cet album entièrement seul. Il y joue guitares, basse, batterie, claviers. Il tient également le micro et a enregistré et mixé le tout. Impressionnant!

L'album contient des titres bien Rock, presque Metal comme Swing of the airwaves, d'autres plus planants comme Porcelain. Les influences sont nombreuses, du rock progressif (certains passages rappellent Oceansize) à la musique orientale.

Une belle découverte!

Ecouter sur Spotify

John Mayer Where the light (Blues/Pop - 2008)

Les albums studio de John Mayer, assez pop, ne m'avaient pas vraiment convaicu. Mais lorsque je suis tombé sur cet album live, j'ai vraiment été bluffé. Dans cet album, et je suppose dans tous ses concerts, c'est vraiment le Blues qui domine. John Mayer est vraiment un excellent guitariste, avec un jeu qui rappele Stevie Ray Vaughan et Jimmy Hendrix. On retrouve d'ailleurs deux reprises de Hendrix et une autre de Ray Charles. Le côté Pop est toujours présent, il permet d’amener des refrains catchy entre 2 solos de guitare pour offrir un blues moderne et peut être plus accessible.

Ecouter sur Spotify

King Crimson - Red (Rock progressif - 1974)

La première moitié des années 70 a été d'une incroyable richesse. Cet album est sorti entre The Dark Side Of The Moon et Wish You Were Here de Pink Floyd, deux autres albums majeurs du rock progressif.
RED est un des disque les plus aboutis musicalement que j'ai pu entendre. Un subtil mélange de rock progressif et de jazz.
Des morceaux comme Fallen Angel ou Starless sont vraiment bluffant, le mélange des guitare, violons et saxophones fonctionne parfaitement et les morceaux sont d'une intensité rare.
Dur à décrire, à écouter absoluement!

Clifford Brown - The definitive (Jazz - 2002)
Cet album contient les plus vieux morceaux de cette sélection. Clifford Brown, trompettiste décédé tragiquement à 26 ans dans un accident de voiture en 1956, a tout de même eu le temps d'enregistrer un nombre impressionnant de titres. Cette compilation en est un excellent témoignage.
On trouve quelques guest stars, dont un duo avec Sarah Vaughan des plus sympathiques.
Malgré l'âge de ces enregistrements, le son est très net et très chaud.
Si vous aimez Miles Davis, je ne peux que vous conseiller d'écouter cet autre grand trompettiste.

Ecouter sur Spotify

Ultra Vomit - Objectif Thunes (Metal parodique)

Certains les appellent "les inconnus du Metal" en référence au célèbre trio d'humoristes. La musique d'Ultra Vomit est à prendre uniquement au second degrès. Parodies et humour décalé sur une musique entrainante et interprétée par d'excellents musiciens. Je les ai vu en concert à Grenoble en Décembre et l'ambiance était vraiment au rendez vous. Vous pouvez voir un autre concert en vidéo ici.

Si vous n'aimez pas trop le Metal vous pouvez regarder du côté d'Andreas et Nicolas, un autre projet du chanteur d'Ultra Vomit, beaucoup plus "chanson française" mais toujours aussi drôle.

Ecouter sur Spotify

Et vous quels ont été vos albums favoris en 2010?

Un livre sur Play Framework

2010-12-29T14:38:00.001+01:00

Introducing Play! Framework, le premier livre sur Play vient de sortir en eBook dans sa version Beta. A cette occasion il est proposé à seulement 5£ (5,84 €) pour les 50 premiers acheteurs.

Je viens d'en faire l'acquisition, c'est un livre en anglais qui va droit au but en présentant les concepts de Play en environ 200 pages. Les bases du framework (MVC, architecture stateless, services RESTful, utilisation d'AJAX...) sont expliqués à l'aide d'exemples de code, ainsi que des notions plus avancées comme la sécurité, l'utilisation des WebSockets ou le développement de modules d'extension.

Les derniers chapitres vous permettront de concrétiser toutes les connaissances acquises durant la lecture en développant 2 applications d'exemple : un racourciceur d'URL et un service de rappels d'événements.

Acheter le livre

vote4music update (Play framework demo app)

2010-12-15T19:34:00.007+01:00

I've just updated my Play framework demo application.

The new things are :

A new vote system (simpler javascript code)
Album covers pictures management
Some tests fixed and improved
New JQuery effects
Bugs fixed

More information and source code download here.

And don't be afraid to use Google code issue tracker if you find a bug :)

Un petit client JQuery mobile

2010-11-20T15:42:00.021+01:00

Ce billet fait suite à celui ci où nous avons appris à exposer un service REST/JSON côté serveur (sur le cloud) avec Google APP Engine.

Voyons aujourd'hui comment consommer un tel service et afficher les résultats sur un téléphone en quelques lignes de javascript à l'aide de JQuery.

Le code suivant permet de récupérer un contenu JSON et d'itérer sur les entrées qu'il contient :

var entries = "http://api.monservice/entries.json";
$.each(data, function(i, entry){          
//traitement de l'élement entry d'indice i

Pour prendre un exemple un peu plus concret, nous allons utiliser l'API Twitter pour afficher une liste de tweets. Les messages seront insérés à l'interieur de l'élément posts.
Après récupération de ces messages nous pouvons ajouter les traitements javascript que l'on veut. Dans notre cas nous allons filter les tweets qui font partie d'une conversation, en ignorant ceux qui commencent par '@':

<head>
// include jquery...
<script type="text/javascript">
function list(url){ $.getJSON( url, function( data ){        
     $('#posts').empty();       
     $.each(data, function(i, post){
                var author = post.user.screen_name;            
      var tweet = post.text;
            var reply = "@"
           // filtrage des tweets commençant par '@'
                if (tweet.substr(0, reply.length) != reply) {
                $('#posts').append(
                '<li>'
                  author
                  ' : '
                   tweet
                 '</li>'
            );
         }
        });
    });
 }

$(document).ready(function(){ 
    var tweets = "http://api.twitter.com/1/statuses/user_timeline/loic_d.json&count=20&callback=?";
    list(tweets);
  
});
</head>
<body> 
<h1>Loic's Tweets</h1>
    <ul id="posts">    
       <li>Getting tweets</li>
    </ul>        
</body>

N.B : L'option callback=? permet de demander à JQuery d'utiliser JSONP pour éviter les problème de cross domain lors du rafraichissement de la page.

Mise en page pour les supports mobiles
JQuery mobile permet d'avoir une mise en page adaptée aux écrans de nos téléphones et tablettes.
Le code suivant génère 2 pages distinctes (tweets et about) à l'affichage avec un effet de "slide". De plus, nous pouvons déclarer notre liste ul comme une 'listview' :

<body>
<!-- Première page -->
<div data-role="page" id="tweets"> 
<div data-role="header">Twitter mobile client</div> 
<div data-role="content">
<div>
<h1>Loic's Tweets</h1>
<ul id="posts" data-role="listview">    
<li>Getting tweets</li>
</ul>
</div>
</div> 
<div data-role="footer">Coffee Bean</div> 
<p><a href="#about">About</a></p> 
</div> 

<!-- Seconde page -->
<div data-role="page" id="about">
<div data-role="header">
<h1>About<h1>
</div>
<div data-role="content"> 
<p>Coffee Bean</p>
<p>With Java sauce</p>
<p>http://coffeebean.loicdescotte.com</p>  
<p><a href="#tweets">Back to tweets</a></p> 
</div>
<div data-role="footer">
<h4>Coffee Bean</h4>
</div>
</div>

</body>

Et voilà, avec ces quelques lignes on obtient une petite page qui pourra tourner sur n'importe quel type de materiel et d'OS!

Télécharger le fichier HTML complet.

Pourquoi Scala? (Introduction)

2010-11-04T14:15:00.007+01:00

Vous entendez parler tous les jours de Scala, tous vos collègues vous disent que le langage Java est devenu sénile (surtout depuis que les modifications les plus intéressantes ont été reportées au jdk8) ? Vous ne savez pas à quoi peut bien servir ce fichu Scala et vous en avez marre de vous sentir idiot lors des discussions devant la machine à café? Cette petite introduction au langage est faite pour vous!

Scala est un langage de programmation statiquement typé, orienté objet et fonctionnel. Comme en Java on utilise le paradigme objet pour modéliser une application et les entités dont elle est composée, mais on a également la possibilité d'implémenter les méthodes de nos classes en utilisant une approche fonctionnelle.
Il est important de savoir que le code écrit en Scala est compilé en bytecode Java afin d'être exécuté sur une JVM. Ceci est une bonne nouvelle pour nous développeurs Java, puisqu'on ne repart pas de zéro sur une nouvelle plateforme : on pourra profiter de toute la richesse des bibliothèques Java, elles seront directement utilisables dans nos projets Scala.

Pour trois petits problèmes simples de programmation, nous allons voir une solution classique en Java et comment Scala pourrait nous simplifier la tache.

Problème 1
J'ai un simple objet avec des attributs x et y. J'ai besoin d'avoir une encapsulation des champs car je veux exposer ma classe à travers une API, sans avoir à casser la compatibilité le jour où je voudrai renvoyer x+1 au lieu de x. Je veux aussi un constructeur utilisant ces champs.

Solution Java
J'encapsule mes champs avec des getters et setters, je crée un constructeur.

public class Rectange{

private int largeur;
private int longeur;

public Rectangle(int largeur, int longueur){
this.largeur=largeur;
this.longeur=longeur;
}

public int getLargeur(){
return largeur;
}

public void setLargeur(int largeur){
this.largeur=largeur;
}

public int getLongeur(){
return longeur;
}

public void setLongeur(int longeur){
this.longeur=longeur;
}

}

On constate qu'on a écrit beaucoup de code pour pas grand chose.... Les comportements de ces getters/setters et du constructeur pourraient être induits à partir d'un fonctionnement par défaut.

C'est cette approche qui est privilégiée dans la solution Scala :

class Rectangle(var largeur: Int, var longueur: Int)

C'est tout! Si on a besoin de redéfinir un getter par la suite on pourra ajouter une méthode sans casser la compatibilité avec les classes appelantes (voir liens en bas du post si vous voulez rentrer dans les détails).

Problème 2
Je veux créer une liste d'entiers et la filtrer pour récupérer uniquement les entiers positifs.

Solution Java

List<Integer> liste = Arrays.asList(-1,2,-3,4,-5,6);
List<Integer> positifs = new ArrayList<Integer>();
for (Integer x : liste){
 if(x > 0)
  positifs.add(x) 
}

Solution Scala

val liste = List(-1,2,-3,4,-5,6)
val positifs = liste.filter(x=>x>0)

On voit bien là la puissance de l'approche fonctionelle de Scala. On passe une fonction anonyme (lambda) à la méthode filter (fournie par l'API Scala) pour retourner une sous partie de notre liste.
Il est possible de définir des prédicats (ou d'utiliser Guava) en Java pour se rapprocher d'une approche fonctionnelle, mais tant que les fonctions lambda seront absentes du langage, on ne pourra pas obtenir une syntaxe aussi élégante.

Problème 3
Je veux ouvrir et parcourir un fichier

Solution Java

String filePath = "fichier.txt";

try{
BufferedReader buff = new BufferedReader(new FileReader(filePath));
try {
List<String> lines = new ArrayList<String>();
while ((line = buff.readLine()) != null) {
lines.add(line);
}
} finally {
buff.close();
}
} catch (IOException ioe) {
System.out.println(ioe.toString());
}

Un peu lourd et surtout pas très lisible (ah les checked exceptions de Java...) !

Solution Scala

val lines = Source.fromFile("fichier.txt").mkString

Ça se passe de commentaires...

Problème 4
Je veux écrire un singleton et y accéder

Solution Java

public class MonSingleton {
    
    private MonSingleton () {
    }
 
    public static MonSingleton getInstance() {
        if (null == instance) {
            instance = new MonSingleton();
        }
        return instance;
    }

    private static MonSingleton instance;
 
 public void hello(){
System.out.println("hello");
}
}

Pour arriver à mes fins j'ai rendu le constructeur par défaut privé, créé une instance statique et une méthode pour y accéder.

Solution Scala

object MonSingleton {
def hello() = {
  println("hello")
}
}

La notion d'objet en Scala permet de définir une instance unique de classe, donc un singleton. A chaque fois que j’accéderai à mon objet en appelant MonSingleton.hello, ce sera la même instance qui sera utilisée.

Tout ceci n'était qu'une mise en bouche, le langage offre beaucoup d'autres possibilités notamment par son approche fonctionnelle.

Je vous suggère de regarder ces articles :

Spring ROO 1.1

2010-10-22T08:35:00.013+02:00

Nous avions vu il y a quelques temps ce que Spring ROO proposait dans une de ses toutes premieres versions.
Depuis j'ai suivi d'un oeil distrait les évolutions de ce framework. Cependant une annonce m'a particulièrement intéressée : Spring ROO intègre désormais GWT comme technologie de présentation.
GWT est décidément en vogue du côté des frameworks RAD en ce moment. Play aussi propose une intégration avec GWT via un module.

Voyons comment ROO a évolué en 1 an et demi. Nous allons créer le même projet que la dernière fois, une bibliothèque de films.

La syntaxe a un peu changé. Cette série de commandes permet de créer notre projet, nos entités et nos CRUD, puis de générer et lancer des tests :

mkdir films
cd films
roo
roo> project --topLevelPackage com.loicdescotte.coffeebean.films
roo> persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY
roo> entity --class ~.Film --testAutomatically
roo> field string --fieldName titre --notNull
roo> field string --fieldName realisateur
roo> field date --fieldName dateSortie --type java.util.Date
roo> controller all --package ~.web
roo> selenium test --controller ~.web.FilmController
roo> gwt setup
roo> perform tests
roo> quit

Il est assez impressionnant de voir tout ce qui est généré quand on tape ces commandes.
On obtient un projet maven complet avec des services Spring, une IHM GWT et des tests JUnit et Selenium.
En tapant "help" dans le shell ROO on s’aperçoit qu'il existe un grand nombre de commandes et qu'il est possible de générer énormément de choses (provider JSON, listeners JMS, bundles OSGI ...).
Le code généré est toujours un mélange de classes Java et d'aspects écrits en AspectJ. Les aspects permettent d'enrichir le code Java, par exemple pour ajouter des fonctions de persistance aux objets du domaine.

Voici la classe java pour mon entité Film :

@RooJavaBean
@RooToString
@RooEntity
@Entity
public class Film {

    @NotNull
    private String titre;

    private String realisateur;

    @Temporal(TemporalType.TIMESTAMP)
    @DateTimeFormat(style = "S-")
    private Date dateSortie;
}

Vous remarquerez qu'ici on ne s'embête pas avec les getters/setters, ils seront ajoutés dynamiquement. On gagne donc en lisibilité.

A côté de ça on a un aspect pour la persistance de nos films (Film_ROO_Entity.aj):

privileged aspect Film_Roo_Entity {

 @PersistenceContext
    transient EntityManager Film.entityManager;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private Long Film.id;

      public static long Film.countFilms() {
        return entityManager().createQuery("select count(o) from Film o", Long.class).getSingleResult();
    }
    
    public static List<Film> Film.findAllFilms() {
        return entityManager().createQuery("select o from Film o", Film.class).getResultList();
    }
    
    public static Film Film.findFilm(Long id) {
        if (id == null) return null;
        return entityManager().find(Film.class, id);
    }

@Transactional
    public void Film.persist() {
        if (this.entityManager == null) this.entityManager = entityManager();
        this.entityManager.persist(this);
    }
    
    @Transactional
    public void Film.remove() {
        if (this.entityManager == null) this.entityManager = entityManager();
        if (this.entityManager.contains(this)) {
            this.entityManager.remove(this);
        } else {
            Film attached = this.entityManager.find(this.getClass(), this.id);
            this.entityManager.remove(attached);
        }
    }

//...

Il y a aussi un aspect pour la méthode toString(), un autre pour les getters/setters.

Quand j'ai découvert ROO j'ai été un peu rebuté par ce mode de fonctionnement. Finalement je le trouve plutôt élégant, il permet de bien isoler les différentes responsabilités du code.

Taper la commande maven suivante permet de lancer l'application :

mvn gwt:run

Et voilà le résultat :

Il est également possible de déployer notre application sur le Cloud avec CloudFroundry (un service de SpringSource reposant sur l’infrastructure d'Amazon), en utilisant ce module.

Tout est donc fait pour qu'on puisse créer et déployer rapidement une application, à un bémol près : attention si vous prenez l'offre d'essai gratuit d'Amazon AWS. On peut vite basculer dans le payant si on dépasse les quotas, il ne semble pas y avoir de verrou sur le paiement comme chez Google.