Groovy

Groovy. Un lenguaje de Scripting que se ejecuta en la Java Virtual Machine

Los lenguajes interpretados o script están en claro auge. Son varias las razones. Por una parte al incremento en la potencia y memoria de las máquinas que los ejecutan y la mejora de los motores de ejecución, lo que evita una de las mayores desventajas hasta ahora como era su menor rendimiento que un código compilado. Por otra parte, desde el punto de vista del programador son lenguajes con una sintáxis más relajada ya que son menos rígidos a la hora de establecer el tipado de datos o determinados tipos de estructuras de programación. La interoperabilidad también es uno de sus puntos fuertes, sirviendo como “pegamento” entre diferentes tecnologías. Lenguajes como Perl, Ruby, o Python son una herramienta perfecta en estos días. Y ni que decir tiene del resurgimiento de Javascript, tnato para HTML5 en los navegadores como en la parte del servidor con NodeJS

Los lenguajes de prográmación interpretados requieren un motor de ejecución que va evaluando de forma secuencial sus instrucciones. Dentro de los muchos existentes llaman la atención aquellos que son capaces de correr en la Java Virtual Machine. Nos estamos refiriendo a Scala, Clojure o Groovy. Es precisamente este último sobre el que trata esta entrada.

Groovy es un lenguaje ligero, dinámico, orientado a objetos y especialmente concebido para ser muy productivo (esto es, con pocas líneas de código se pueden hace maravillas). Y sobre todo, corre en la JVM y es compatible con Java. Sí, podemos utilizar código Java dentro de Groovy, así como las librerías de Java. Por decirlo de modo vulgar: podemos hacer todo lo que puede hacer Java y además muchas otras cosas de un modo más fácil. Existe una framework llamado GRails (como Ruby on Rails) para el desarrollo de aplicaciones basado en Groovy.

¿Por qué usar Groovy? Si ya sabes Java puede ser una buena herramienta para todo tipo de desarrollos rápiudos o como complemento al código de Java más complejo que hemos realizado. Por ejemplo, si queremos descargar el código fuente de una URL y salvarlo a disco, en Groovy simplemente son necesarias dos líneas de código:

def contenido = "http://www.rusizate.com".toURL().getText()
new File("forocoches.html").append(contenido)

No creo que sea necesario que te compare con el número interminable de líneas de código que requiere esto en Java. Entre los imports, la definición de una clase básica, su método main, establecer la conexión, abrir los streams, comunicarlos con un fichero y descargar en un buffer byte a byte…

De este modo podemos hacer muchas operaciones rápidas y muy útiles, además de utilizar Groovy para ejecutar el script simplemente, sin necesidad de generar los .class y luego ejecutarlos. Todo va directo. Por ejemplo, para listar una select por pantalla de una base de datos SQL Server y guardarlo en base de datos:

import groovy.sql.Sql

sql = Sql.newInstance("jdbc:sqlserver://servidor:1433;databaseName=baseDatos", "sa", "password","com.microsoft.sqlserver.jdbc.SQLServerDriver");
def salida=""
sql.eachRow("select * from tabla", {salida+=" ${it.PK1} - ${it.NOMBRE}" + System.getProperty("line.separator")})

new File("d:\\salida.txt") <<salida
println salida

También es tremendamente útil para probar nuestro código Java. El desarrollo TDD (Test Driven Development) se está demostrando muy eficaz en la creación de todo tipo de aplicaciones. Groovy, al poder interactuar con nuestro código Java (o cualquier .jar que utilicemos) nos puede servir para probar nurestro código o desarrollar test de forma muy rápida. O también integrarnos con otros sistemas.

En definitiva Groovy es una buena herramienta de scripting si estás habituado a Java. Y manejar un lenguaje de script hoy en día es fundamental para poder interconectar multitud de sistemas o simplemente ser productivos en aquellas tareas que son secundarias. Y todo esto sin olvidar que es un lenguaje orientado a objetos y que cada vez hay más de manda de profesionales con conocimientos de Grails.

Explicar el lenguaje entero llevaría bastante tiempo. Si sabes Java te resultara fácil porque siempre que te veas atascado podrás recurrir a tus conocimientos de Java. No obstante, cuando empieces a ver la potencia y sencillez de la sintáxis propia de Groovy rápidamente verás cómo querras saber más y más instrucciones nativas que sustituyen a la tediosa y estricta sintáxis de Java.

Existen mutlitud de páginas y libros sobre Groovy y algunos especializados en enseñar a los que ya saben programar en Java. Puedes probar con este si lo deseas: http://www.amazon.es/Programming-Groovy-Productivity-Developer-Programmers/dp/1937785300/ref=sr_1_fkmr1_3?ie=UTF8&qid=1390724841&sr=8-3-fkmr1

¿Cómo puedo empezar con Groovy?

Es muy sencillo, solamente tienes que tener una máquina virtual de Java (JVM) instalada en tu equipo, y descargar Groovy desde su página principal: http://groovy.codehaus.org/

Una vez descomprimido tienes que establecer como variable del sistema GROOVY_HOME el directorio en el que está ubicado.

En GROOVY_HOME/bin tienes los ejecutables. Dentro de todos los que aparecen hay dos interesantes: groovy.bat con el que ejecutar los scripts de Groovy y groovy-console.bat para lanzar una consola en la que poder programar los scripts y ejecutarlos (Ctr+R para RUN y Ctrl+W para limpiar pantalla).

Así puedes comenzar con el ejemplo típico:

println "Hola Mundo"

O algo más complejo

println "Hola mundo"

def vector=[]
def texto
1.upto(3)
{
texto = it + " - Hola Mundo"
vector<<texto
}

println vector.join(" | ")

Con teste código hemos definido un ArrayList en el que se van introduciendo los valores de “texto” en cada momento. La variable “it” representa el valor del contador y el “add” clásico para introducir valores a un vector se puede hacer mediante el operador “<<“. Finalmente se muestran por pantalla todos los elementos del vector, separados mediante esta cadena ” | “. Sencillo, ¿no?

Para ejecutarlo simplemente presiona Ctrl+R y ya estará corriendo. Mucho más rápido que usar Java.

Si estás acostumbrado a Java echarás de menos el autocompletar que tienen los editores como Netbeans o Eclipse. No te precupes porque existe un plugin para que desarrolloes Groovy en Eclipse, con todas las ventajas que esto conlleva (entre ellas la del autocomplete).

Accede a http://groovy.codehaus.org/Eclipse+Plugin e instalar Groovy-Eclipse eligiendo la URL adecuada para tu versión. Ya sabés… en Eclipse ir a Help->Install new Software… Si tenéis ya instalado el M2E (Maven para Eclipse), es probable que exista un conflicto que dificulte la instalación.

Una vez instalado el plugin, se crea un archivo nuevo de tipo Groovy Class y se puede programar. Recordar que se tiene que correr como Groovy, no como servidor o aplicación Java.

Si estáis acostumbrados a otros editores, como por ejemplo del magnífico Sublime Text 2, también es fácil ponerse a trabajar con Groovy. Simplemente salvamos el fichero como .groovy y la sintáxis debería cambiar. Para ejecutarlo vamos al menú Tools>Build System>New Build System. Se abrirá una ventana nueva donde podremos pegar el siguiente código:

{ "cmd": ["F:\\groovy-2.2.1\\bin\\groovy.bat", "$file"] }

Donde F://… es la ruta donde yo tengo mi GROOVY_HOME. La tuya probablemente sea otra.

Ahora simplemente presionando Ctrl+B podrás correr los scripts de Groovy en Sublime Text 2.

Un último apunte que me costó trabajo encontrar: cuando tengamos que utilizar otras bibliotecas como la de base de datos por ejemplo para acceder a SQL, necesitaremos dejar los ficheros .jar en algún lugar accesible. El lugar en el que funciona es el del usuario/.groovy/lib (en mi caso para W7 es C:\Users\mysticalpotato\.groovy\lib). Copiando ahí los .jar no habrá problemas de clases no encontradas.

El ejemplo

Una vez ya estamos con toda la información vamos a ver un pequeño ejemplo de integración de una librería de Java dentro de Groovy y de cómo es de sencillo utilizar Groovy para tareas que en Java nos llevarían decenas de líneas de código.

El ejemplo consiste en descargar a un fichero las portadas de los subforos del conocido foro Forocoches (no un foro de coches, sino Forocoches) y mostrar los asuntos de los mensajes que hay en portada gracias a la libería jsoup (http://jsoup.org/). Está basado en esta magnífica serie de post sobre cómo hacer scraping web con Groovy (http://imediava.wordpress.com/2011/08/18/web-scraping-with-groovy-1-of-3/). El código Groovy es el siguiente:

import org.jsoup.nodes.Document
import org.jsoup.Jsoup

def tamanho = -1
def contenido
def listado_foros_validos = []
def result

def fichero = new File("forocoches.html")
def contador_mensajes = 0

0.upto(60)
{
contenido = "http://www.forocoches.com/foro/forumdisplay.php?f=$it".toURL().getText()

tamanho=contenido.length()/1024
if (!contenido.contains("Foro especificado"))
{
println "Tamaño $it: $tamanho kb | "
listado_foros_validos.add(it)

fichero.append(contenido)

Document doc = Jsoup.parse(contenido)
results = doc.select(".page ul")[1]
results?.select("li a")?.each()
{
println it.text()
contador_mensajes++
};

}
}

println "Foros validos: " + listado_foros_validos
println "Mensajes totales: " + contador_mensajes

Algunas de las peculiaridades que merece la pena comentar:

  • La librería jsoup (http://jsoup.org/) nos permite parsear una cadena de texto (o una URL) y analizarla utilizando selectores tipo JQuery. Es una librería excelente que recomiendo dominar. Se tiene que descargar el fichero .jar de esta librería y dejarlo en nuestra home/.groovy/lib para que Groovy tenga acceso. Vemos cómo se hace el import de librerías en Groovy, similar a Java.
  • Jugamos con el modo de identificar los subforos en la URL. El parámetro “f” seguido de un número entre 1 y 60 nos va a indicar el subforo correspondiente. Si algún número nos lleva a un subforo inválido lo indica con la cadena de texto “Foro especificado”.
  • Es muy fácil descargar el código de una página mediante String.toURL().getText()
  • Añadimos a un vector llamado “listado_foros_validos” los índices que indican suforos válidos.
  • Escribimos en un fichero con append(String).
  • de Jsoup podemos destacar el parse de la cadena de texto y la operacion “select” que recibe por parámetro unos selectores tipo jQuery
  • El operador “?” es destacable. Es equivalente a if(elemento!=null){} Es decir, que result?.select hace algo así como “si result no es nulo entonces haz la instrucción select”.
  • Podemos recorrer un objeto de tipo array con .each(), siendo it el elemento que se corresponde en cada iteración.

En definitiva, Groovy es un lenguaje de scripting que merece la pena conocer si estás familiarizado con Java. Es muy potente gracias a su sintáxis altamente productiva y la posibilidad de interactuar con Java.

Anuncios