lundi 20 juin 2011

JAVA et Groovy

Groovy est un langage de programmation, basé sur Java et s'intégrant très bien avec tout son écosystème.

Pour vanter quelques mérites de Groovy voici des exemple Groovy VS Java :



JAVA
--------
String name "World"
System.out.println("Hello " name);

GROOVY
-----------
def name "World"
println "Hello $name"


JAVA
--------
Map<StringStringparams new HashMap<StringString>();
params.put("key""value")
System.out.println(params.get("key"))

GROOVY
-----------
def params [key"value"]
println params.key



JAVA
--------
public class Customer {

    private String name;

    private int age;

    Customer({
    }

    Customer(String nameint age{
        this.age age;
        this.name name;
    }

    public String getName({
        return name;
    }

    public void setName(String name{
        this.name name;
    }


    public int getAge({
        return age;
    }

    public void setAge(int age{
        this.age age;
    }

    @Override
    public boolean equals(Object o{
        if (this == oreturn true;
        if (== null || getClass(!= o.getClass()return false;

        Customer customer (Customero;

        if (age != customer.agereturn false;
        if (name != null !name.equals(customer.namecustomer.name != nullreturn false;

        return true;
    }

    @Override
    public int hashCode({
        int result name != null name.hashCode(0;
        result 31 result age;
        return result;
    }

    @Override
    public String toString({
        return "Customer{" +
                "name='" name '\'' +
                ", age=" age +
                '}';
    }

    public static void main(String[args{
        Customer toto new Customer("Toto"7);

        Customer toto2 new Customer();
        toto2.setName("Toto");
        toto2.setAge(7);

        System.out.println(toto.equals(toto2));
    }
}


GROOVY
-----------
import groovy.transform.

def toto new Customer(name'Toto'age7)

def toto2 new Customer()
toto2.name 'Toto'
toto2.age 7

assert toto == toto2

@ToString 
@EqualsAndHashCode 
class Customer{

  String name

  int 
age


}






Comme vous le voyez, Groovy permet d'avoir une syntaxe bien plus concise que l'équivalent en Java.

Moins de code à écrire == plus facile à développer == plus facile à lire (une fois que l'on a l'habitude) == plus facile à maintenir...


Et la liste est longue des Groovyness utilisables : 
  - la gestion des collections : filtrage, trie, modification, .... (simplifié grâce à la programmation fonctionnelle) : http://groovy.codehaus.org/Collections
  - la gestion des dates : http://groovy.codehaus.org/JN0545-Dates
  - la création de script dépendant de librairies présent sur Maven : http://groovy.codehaus.org/Grape
  - éviter les null pointer exceptions avec les opérateurs ?. et ?: : http://docs.codehaus.org/display/GROOVY/Operators#Operators-ElvisOperator%28%3F%3A%29
  - la gestion des fichiers : http://groovy.codehaus.org/JN2015-Files
  - toute les exceptions sont gérées comme des RuntimeException
  - ...

Groovy est un langage qui évolue vite, actuellement nous sommes à la version 1.8. Cette version ci rajoute un certain nombre de fonctionnalités intéressantes comme le support natif du JSON, l’annotation @Log qui permet d'injecter un logger (slf4j, log4j, ...), @ToString et @EqualsAndHashCode que je viens de vous montrer et encore pleins d'autres choses merveilleuses à découvrir ici : http://docs.codehaus.org/display/GROOVY/Groovy+1.8+release+notes






Depuis plus d'un an que j'utilise groovy tous les jours, je n'ai toujours pas rencontré de bug. Nous l'avons utilisé pour des scripts, des tests et des applications en production (http://www.grails.org/). C'est un langage que je recommande vraiment. Pour un développeur Java, c'est vraiment une bouffé d'air frais.

Il n'y a pas que des avantages, Groovy est lent, mais je trouve que le temps gagné lors de la phase de développement en vaut la chandelle.

Groovy est dynamique et n'est pas fortement typé, ce qui nécessite d'écrire plus de test unitaire. C'est peut être là sont plus gros défaut. 

Néanmoins, ces problèmes disparaîtront peut être un jours car les performance de Groovy ne font que s'améliorer avec le temps. De plus groovy++ est un projet prometteur car il ajoute un typage statique et des performances équivalentes à celles de Java. Mais je ne l'ai encore jamais testé.

L'intégration avec les IDE n'est pas forcement parfaite : 
  Netbeans -> moyen, 
  IntelliJ -> excellent, équivalent à Java

Mais l'integration avec Maven ne pose aucun problème : http://docs.codehaus.org/display/GMAVEN/Building+Groovy+Projects

Concernant les tests je conseille le framework Spock, sinon un simple JUnit fait très bien l'affaire. Pour du BDD, on peut utiliser EasyB, mais je préfère quand même Spock.

Come Java, Groovy ne favorise pas l'immutabilité (contrairement à scala) est c'est bien dommage pour les applications multi-threadées.

GPars a été intégré avec Groovy depuis la version 1.8 pour simplifier la programmation multi-threadée, mais j'ai encore un peu de mal à l'utiliser. Je ne trouve pas l'API intuitive. Mais bon je vais surement m'y habitué.

Pour avoir également testé Scala quelques jours, Groovy est peut être moins puissant mais est plus facile à prendre en main lorsque l'on est habitué à Java. Mais Scala semble quand même plus robuste et plus simple pour tout ce qui concerne le développement d'applications multi-threadées, tolérantes aux pannes et scalable  : http://akka.io/

2 commentaires:

  1. Bonsoir, eh bien je vais donner mon humble avis concernant ton article.

    Tout d'abord, sache que je n'ai qu'une maigre expérience professionnelle concernant un projet Grails (mais un projet très intéressant).

    Ma première remarque, je trouve quelques erreurs qui me pique les yeux ^^ ("venter", "un syntaxe"). Bon on pourrait me dire que ce n'est pas le coeur du sujet.

    Ensuite, sur le contenu, j'avoue que la syntaxe est carrément plus light oui mais de là à dire : "Moins de code à écrire == ... == plus facile à lire". Ca je ne suis pas d'accord, ce n'est pas forcément obligatoire (justement Groovy demande un temps d'adaptation à tout développeur Java en terme de syntaxe). Plus court n'est pas forcément plus clair surtout pour débuter sur Groovy.
    Moi, de mon expérience, là où j'ai trouvé Groovy intéressant dans un projet Java, c'est dans la création d'objet Dao qui contiennent donc une syntaxe qui déjà en Java est simple. Là oui, un SI se construit vite.

    Mais mon gros bémol (à l'époque en tout cas), c'est l'intégration sous Eclipse. Grand habitué d'Eclipse et étant mon IDE préféré, j'ai du subir la mauvaise intégration de Groovy.
    Autre bémol totalement normal, c'est la communauté. Groovy est jeune, du coup, la communauté est restreinte (en comparaison, il est sur d'avoir rencontré tout les problèmes en Java sur le net ^^).

    PS : Sinon bonne idée de faire ces articles sur ce langage qui a besoin d'adepte ^^

    RépondreSupprimer
  2. Merci,

    Pour les fautes, j'ai corrigé celles que tu m'as dis, et j’espère qu'il n'en reste pas trop.

    Pour la DAO, je suis entièrement d'accord, mais je pense écrire un article complet sur le sujet tellement c'est efficace et pratique à tester. En tout cas côté JAVA, Spring Data JPA et Hades essayent de se rapprocher des dynamic finders de Gorm.

    Concernant l'IDE je suis d'accord avec toi, c'est tellement important un bon IDE. IntelliJ est excellent pour ça, mais il est payant pour du développement web. Je vais tester de nouveau Netbeans pour voir ce qu'il vaut maintenant.

    Sinon je trouve la communauté Groovy assez réactive, en tout cas sur la mailing list. Les docs officielles sont bien rédigées, avec plein d'exemples, et la Groovydoc est plutôt efficace.

    ++

    RépondreSupprimer