Contribuye

title: ‘De Java hacia Groovy’ author: MIguel-1.mx date: 2009-05-17 url: /2009/05/17/de-java-hacia-groovy/ categories:

- Groovy

Así como para aprender a conducir se necesita conducir, o para aprender a besar se necesita besar, Groovy se aprende con Groovy. En el taller de Groovy impartido por el Ing. Domingo Suarez, como parte de la sexta reunión de SpringHispano.org y JavaMexico.org se incluyó la siguiente charla, que me pareció oportuna como punto de comparación entre Groovy y Java. Se mostró mediante ejemplos la compatibilidad entre Groovy y Java: un programa para la consola escrito en Java:

HelloWorld en Java:

public class HelloWorld {
    String name;
 
    public void setName(String name)
    { this.name = name; }
    public String getName() { return name; }
 
    public String greet()
    { return 'Hello '+ name; }
 
    public static void main(String args[]){
       HelloWorld helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       System.err.println( helloWorld.greet() )
    }
 }

Enseguida, el HelloWorld en Groovy:

public class HelloWorld {
    String name;
 
    public void setName(String name)
    { this.name = name; }
    public String getName() { return name; }
 
    public String greet()
    { return 'Hello '+ name; }
 
    public static void main(String args[]){
       HelloWorld helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       System.err.println( helloWorld.greet() )
    }
 }
 

Muy bien. Entonces, ¿cuál es la diferencia? Ah, este ejercicio no mostraba la manera de trabajar con Groovy, sino que la curva de aprendizaje para un programador de Java es prácticamente de cero, es decir, si no recuerdan o no conocen cómo opera Groovy en algún punto específico, se puede escribir la porción en cuestión vía Java con el mismo resultado, pues prácticamente cualquier código en Java se puede trasladar a Groovy (son muy pocas las incompatibilidades). ¿Y cuáles son las ventajas? Se describieron poco a poco:

Groovy tiene la noción de ‘convención sobre configuración’, en otras palabras, no da suma importancia a los detallazos como el punto y coma tras cada oración, y todo en Groovy es público a menos que se especifique lo contrario. Con estos dos puntos, se comenzó el camino del HelloWorld hacia la manera de Groovy:

Hacia el HelloWorld de la manera Groovy (1):

class HelloWorld {
    String name
 
    void setName(String name)
    { this.name = name }
    String getName() { return name }
 
    String greet()
    { return 'Hello '+ name }
 
    static void main(String args[]){
       HelloWorld helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       System.err.println( helloWorld.greet() )
    }
 }
 

En este orden de ideas, Groovy llama ‘datos básicos’ (o ‘boilerplate’ en inglés) a la información fundamental de la organización al inicio de cualquier programa en Java: todos sabemos que para programar un JavaBean se requiere un par de get/set para cada propiedad: dejemos que Groovy lo escriba por uno. Lo mismo con Main(): siempre requiere String[] como parámetro. Dejemos que Groovy haga esa definición más corta con tipos opcionales. Enseguida, si imprimir a la consola es tan común, ¿podemos tener una versión más corta también?. Con Groovy, sí. Veamos cómo queda:

Hacia el HelloWorld de la manera Groovy (2):

class HelloWorld {
    String name
 
    String greet()
    { return 'Hello '+ name }
 
    static void main( args ){
       HelloWorld helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       println( helloWorld.greet() )
    }
 }
 

Groovy usa la palabra clave def cuando no es indispensable indicar el tipo de variable, de manera similar a la palabra clave var en JavaScript. De esta manera Groovy deducirá el tipo correcto. A esto se le llama ordenamiento de tipos dinámicos (duck typing en inglés):

Hacia el HelloWorld de la manera Groovy (3):

class HelloWorld {
    String name
 
    def greet()
    { return 'Hello '+ name }
 
    static def main( args ){
       def helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       println( helloWorld.greet() )
    }
 }
 

Los GStrings proporcionan interpolación de variable, como en Ruby o Python: Con anteceder ${} dentro de un String bastará:

Hacia el HelloWorld de la manera Groovy (4):

class HelloWorld {
    String name
 
    def greet() { return 'Hello ${name}' }
 
    static def main( args ){
       def helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       println( helloWorld.greet() )
    }
 }
 

Ahora bien, no es necesario usar ‘def’ en métodos estáticos, y es opcional la palabra clave ‘return': el valor de retorno de un método será la última expresión evaluada. En Groovy se traduce:

Hacia el HelloWorld de la manera Groovy (5):

class HelloWorld {
    String name
 
    def greet() { return 'Hello ${name}' }
 
    static main( args ){
       def helloWorld = new HelloWorld()
       helloWorld.setName('Groovy')
       println( helloWorld.greet() )
    }
 }
 

Acto seguido, el concepto de POJOs en esteroides. Los POJOs no sólo escriben sus propios accesorios de propiedad. Los POGOs (manera Groovy) también proporcionan un constructor predeterminado con parámetros (símiles) nombrados; además, soporte para subscripts de arreglo (bean[prop]) y notación de punto (bean.prop) para acceder a propiedades:

Hacia el HelloWorld de la manera Groovy (6):

class HelloWorld {
    String name
 
    def greet() { return 'Hello ${name}' }
 
    static main( args ){
       def helloWorld = new
                HelloWorld(name:'Groovy')
       helloWorld.name = 'Groovy'
       helloWorld['name'] = 'Groovy'
       println( helloWorld.greet() )
    }
 }
 

Por último (para esta demostración), Groovy soporta scripts (aunque compile clases a código de byte Java), y esos scripts también se compilan a código de byte Java. Dichos scripts permite que se definan clases en cualquier lugar sobre ellos y soportan paquetes, pues también son clases Java válidos.

HelloWorld a la manera Groovy (7):

class HelloWorld {
    String name
    def greet() { return 'Hello ${name}' }
 }
 
    def helloWorld = new HelloWorld(name:'Groovy')
       println( helloWorld.greet() )
 

Contra esta última versión hay un abismo de diferencia con el primer ejemplo, en Java. No obstante, sigue siendo Java. Groovy sigue el ‘mantra': Java es Groovy, Groovy es Java’, y aquí se demuestra la compatibilidad a su máxima expresión. Casi el 98% del código Java es compatible con código Groovy. Podría cambiar la extensión de *.java a *.groovy y funcionará.

comments powered by Disqus