Repasando algunas caracteristicas de Groovy

En este articulo veremos y explicaremos algunas de las caracteristicas de Groovy para aprender mas sobre este lenguaje dinámico, esperemos que les guste y espero muchas preguntas y/o comentarios.

Antes de comenzar este pequeño articulo debo de hacer una advertencia, y es que este artículo asume que ya instalaste Groovy y por lo menos sabes que es Groovy, si es todavia no lo haz instalado o no sabes que es Groovy, en la internet hay muy buenas guias que te pueden servir de ayuda.
Por otro lado tambien decirles que para ejecutar cada ejmplo de Groovy he utilizado la CONSOLA DE GROOVY(esto se logra escribiendo en la consola $groovyConsole), desde alli puedes ejecutar cada uno de los ejemplos que les muestro... diviertanse.

Objetivo.- como dije al principio, es el dar a conocer algunas caracteristicas de Groovy, se verán algunas diferencias y sobre todo como Groovy ahorra muchas líneas de código al programar y por ende nos hace la vida mas fácil. En conclusión mi objetivo es que se enamoren de este lenguaje.

Comenzaré por decir que en Groovy hay una serie funcionalidades que son opcionales, que detallo a continuación:

- En groovy el punto y coma (';'), al final de cada sentencia es opcional, .
- Los paréntesis '()', tambien son opcionales: ejm:
printl "hola" || tambien puede ser asi: println("hola")

- En un archivo .groovy se importa automaticamente los siguientes paquetes, asi es que no hay necesitad de importarlos explicitamente.
- groovy.lang.*
- groovy.util.*
- java.lang.*
- java.util.*
- java.net.*
- java.io.*
- java.math.BigDecimal
- java.math.BigInteger
- En groovy no es obligario el manejo de Excepciones Ejm:
[sourcecode language='java']
import groovy.sql.Sql
class GroovySqlExample1{
static void main(String[] args) {
def sql = Sql.newInstance("jdbc:mysql://localhost:3306/myBD", "root","root", "com.mysql.jdbc.Driver")
}
}
[/sourcecode]
- El retorno al final de cada método y/o bucle ya no son necesarios, en groovy la ultima sentencia que se ejecuta (en el caso de un closure) es lo que retorna. ejm:
[sourcecode language='java']
def retornotrue= {
x,y ->
x*y
}
def z= retornotrue(4,8)
[/sourcecode]
En este caso el closure recibe dos parametros (devuelve el producto de x*y) el resultado de ejecutar este codigo nos dará 32.

- Como habrán notado en el anterior ejemplo, estoy obviando el tipo de declaracion de las variables, lo cual sí esta permitido en Groovy, es por lo tanto un lenguaje opcionalmente tipado.

- También he usado la palabra 'def', pues esta palabra no es mas que una variable dinamica usada bastante en los lenguajes dinámicos como lo es Groovy.
por ejemplo:
[sourcecode language='java']
def varStr = "cadena"
def varInt = 345
println varInt.getClass()
println varStr.getClass()
[/sourcecode]
La ejecución de este código nos dará el sgte resultado:
class java.lang.Integer
class java.lang.String

De este modo comprobamos lo que estamos diciendo, la variable 'def' se comporta de una manera dinamica, adecuandose al tipo de variable que tiene al frente de ella.
Definiremos lo que es tambien un Closures, que en terminos prácticos digamos que es un método y se han fijado son muy parecidas a las clases anominas que existen en Java, para describirlo mejor es una porcion de código encerrado entre llaves, se pueden asignar a variables como si fuera un objeto más y por supuesto pueden recibir parametros y lo que retorna es la última sentencia que se ejecuta. Todo esto aporta agilidad y eficiencia a la hora de escribir un codigo.
Por Ejm:
[sourcecode language='java']
def lenguajes=['Java','Scala','Python','Groovy']

def imprime = lenguajes.find{
if(it.equals('Groovy')){
println "Estoy en Groovy"
return
}
println("estoy en otro lenguajes")
}
[/sourcecode]
En este caso estoy definiendo una lista de Strings, que despues las mando a través del closure 'imprime', llamo al metodo 'find()'(el cual hace una busqueda usando hibernate) y si es que encuentro una palabra que coincida con 'Groovy' que imprima "Estoy en Groovy", en caso contrario "Estoy en otro lenguaje".

Veamos un ejemplo de como haces un archivo xml en Groovy
[sourcecode language='java']
def sw = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(sw)
xml.langs(type:"current"){
language("Java")
language("Groovy")
language("JavaScript")
}

def writer = new File("lenguajes.xml")
writer.write(sw.toString())
[/sourcecode]
el resultado seria un archivo .xml que se llamará lenguajes.xml, y mostrará lo siguiente:
[sourcecode language='java']

Java
Groovy
JavaScript

[/sourcecode]
También se puede hacer un .groovy con codigo java puro (como ya lo mostré en un blog anterior), pero no tendría sentido ya que no podriamos aprovechar las bondades que nos brinda groovy.

Como se habrán dado cuenta, en groovy se simplifica las lineas a codificar y por supuesto disminuye el riesgo de errores.