Características básicas Groovy


Cuando desarrollas durante el día a día sobre Java nunca has querido agilizar el desarrollo con una sintaxis mas directa o simplemente quieres corroborar alguna idea que tienes en mente, alguna solución y te encuentras con el código repetitivo de Java, si es asi puedes tomar en cuenta incorporar a tu caja de herramientas Groovy.

Ahora bien!, ¿Qué es Groovy?, de forma resumida Groovy es un lenguaje de programación veloz que interactua con Java y que brinda mas herramientas al desarrollador, podriamos decir que Groovy es Java con super poderes.

¿Que debemos hacer para utilizar Groovy?, si bien este artículo no se trata de como instalar Groovy, en una plataforma basada en Windows siemplemente seria seguir estos pasos:

1. Tener instalado Java.
2. Descargar el instalador correcto directamente desde la pagina de Groovy.
3. Inicar el instalador descargado.
4. Seguir los pasos dictados por el instalador, donde se establecen parámetros como lo son: selección de componentes, localización de la instalacion y creacion de variables de entorno.
5. Una vez completado el proceso anterior podriamos validar la correcta instalacion por medio de la interfaz de comandos, digitando groovy –version o simplemente groovy -v

Si deseas tener una información mas completa de la instalación en ambientes Windows o de otros sistemas operativos puedes visitar https://groovy-lang.org/ y dirigirte al área correspondiente al tema.

Pues iniciemos a discutir algunas de las facilidades que brinda este lenguaje de programación.

Algunas cosas que veremos serán las siguientes:

  1. Tipado.
  2. Iteración de listas o mapas.
  3. Interpolación de cadenas de texto.
  4. Conversiones.
  5. Que hacer con JSON y objetos.
  6. Afirmaciones.
  7. Validación a la hora de apuntar a algun objeto nulo.
  8. Operador «Spread».
  9. No «getters» ni «setters»

Inicialmente, veamos este ejemplo codificado en Groovy siendo el mismo el codigo necesario para realizar la salida de una cadena de texto.

print 'Java User Group Costa Rica!.'

¿Que podemos ver el código anterior?, pues donde esta el código repetitivo en que definimos la clase y el método principal para crear la salida de una cadena de texto y donde esta el famoso punto y coma que a mas de uno nos causa dolor de cabeza, pues con Groovy nada de eso es necesario, simplemente la idea detras de esto es hacer el código menos verboso, lo cual es genial para crear un codigo mas lejible a simple vista. Muchas veces tenemos una lucha mentan de seguirle el paso cuando estamos validando el código de los sistemas en que estamos trabajando dado que Java es propenso a ser mucho mas cargado sintacticamente.

Ahora bien que sucede si estas utilizando Groovy en tu desarrollo y no recuerdas la sintaxis del mismo pues Groovy te deja utilizar todas las sentencias Java que habitualemente utilizas dando esto una exelente flexibilidad.

Empecemos.

1. Tipado.

Groovy es un lenguaje de tipado opcional, esto quiere decir que puedes o no definirle el tipo a tus variables o simplemente utilizar la palabra reservada , si hemos utilizado anteriormente cualquier lenguaje de script como lo es Javascript o Python, sabemos que muchas veces puede llegar a hacer algo dificil a la hora de por ejemplo, determinar el tipo de una variables despues de algun proceso, brinda demasiada flexibilidad pero esto tiene un precio.

//variables definition
String name
def lastName
int age
def month
def friend = ["Java", "User", "Group"]
def myList = []
def myMap = [:]

//methods definition
def getFooValue(String input) { 
	print input
}

2. Iteracion de listas de mapas.

Para este fin Groovy nos ofrece utilizar «Clousures» esto resulta en una sintaxis mas limpia y concisa.

def myList = []

myList.each {element -> 
    println element
}

3. Interpolación de cadenas de texto.

Alguna vez hemos tenido la necesidad de impirmir un texto compuesto por un juego de contenido estático y el valor de una variable en determinado momento de ejecución, para esto muchas veces caemos en la necesidad de la concatenación por medio de el operador +, Groovy nos brinda la opción de realizarlo por medio de el simbolo $ eh indicando la variable que queremos imprimir, de la siguiente manera

String[] blogs = ["Swagger", "TimerClass", "Groovy"]

blogs.each {entry -> 
    println "Blog: $entry"
}

4. Conversiones.

Para esto Groovy nos brinda la utilización de la palabra reservada , siendo un requisito la implementacion de el metodo en nuestras clases y de lo contrario no es requisito si utilizamos clases como o .

Integer x = 123
String s = x as String

class Identifiable {
    String name
}
class User {
    Long id
    String name
    def asType(Class target) {                                              
        if (target == Identifiable) {
            return new Identifiable(name: name)
        }
        throw new ClassCastException("User cannot be coerced into $target")
    }
}

def u = new User(name: 'Xavier')                                            
def p = u as Identifiable                                                   

print p.name

5. Que hacer con JSON y objetos.

Hoy en día es de vital importancia la necesidad de trabajar con imformación en formato JSON para esto Groovy nos demuestra lo sencillo que es tomar el contenido JSON y generar un objeto apartir de él.

import groovy.json.JsonSlurper 

class Blog {
	String name
	String language
	String topic
}

String response = '{"name":"JUG CR", "language:"Java", "topic":"Groovy"}'

// Json response to map
def blogMap = new JsonSlurper().parseText(response)

// Consider an Blog class with the attributes name, language and topic
Blog blog = new Blog(blogMap)

6. Afirmaciones.

Para esto podemos hacer uso de la clase «PowerAssetionError» esto nos brinda la posibilidad de visualizar el incumplimiento de una afirmacion en la salida de la ejecución.

def topics = ['struts', 'groovy', 'java']

assert topics.isEmpty()

//----------Console Output ----------
//
// assert topics.isEmpty()
// 
// Caught: Assertion failed:
// 
// assert topics.isEmpty()
//        |      |
//        |      false
//        ['struts', 'groovy', 'java']
// 
// Assertion failed:
// 
// assert topics.isEmpty()
//        |      |
//        |      false
//        ['struts', 'groovy', 'java']
// 
// 	at Example1.run(Example1.groovy:3)
// 	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
// 	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:64)
// 	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

7. Validación a la hora de apuntar a algun objeto nulo.

Personalmente y creo que muchos a la hora de programar hemos sido victimas de la infame excepcion , si les comentara que hay una forma de validar si un objeto al que tratamos de acceder es nulo sin tener la necesidad de recurrir al igualmente infame lógica de protegernos por medio de un if, si bien serian un par de lineas de codigo mas o una cascada de sentencias if seria código inncesario si tenemos a la mano Groovy simplemente podemos utilizar el simbolo ?.

class Blog {
	String name
	String language
	String topic
}

Blog foo = null

print foo?.name

8. Operador «Spread».

Por medio de el simbolo <*> aplicado sobre los elementos de una una colección podemos ejecutar cierta rutina a todos ellos sin necesidad de tener que itirarlos siquiera.

class Blog {
	String topic
	int uid
}

def entries = [
    new Blog(topic: 'Code Smells', uid: 0001),
    new Blog(topic: 'Refactoring', uid: 0002)
]

def entriesTopics = entries*.topic

print entriesTopics

9. No «getters» ni «setters»

Para esto existen muchas opciones para lograrlo por ejemplo si se esta utilizando un framework como Spring por medio de anotaciones o por medio de el uso de librerias como Lambok, siendo Groovy una de ellas, les comento sobre lo tedioso que puede llegar a hacer tener que declarar los metodos para acceder al contenido de las variables de un objeto, conocidos como «getters» y «setters», Groovy trata de enterder el comportamiento de las propiedades a las que se quiere acceder teniendo en cuenta lo siguiente:

  • Si una propiedad de una clase es declarada sin ningún modificador, se genera un campo privado con sus correspondientes métodos getter() y setter().
  • Si una propiedad de una clase es declarada como final, dicha propiedad será privada y se definirá también su getter(), pero no su setter().
  • Si necesitamos una propiedad de tipo privado o protegida debemos declarar sus métodos getter() y setter()de forma privada o protegida.
class Blog {
    String topic
    int uid
}

Blog blog = new Blog()

blog.topic = "Java Basics"
blog.uid = 0001

print blog.topic

El código fuente completo de este ejemplo está disponible en este repositorio de GitHub.


Conclusión.

Tal y como pudimos observar, recorrimos brevemente atravez de las ventajas de utilizar Groovy como parte de nuestras herramientas.

Personalmente encuentro extremendamente util en el proceso díario de desarrollo, brinda una gran flexibilidad, los reto a descubrirlo eh integrarlo a su caja de herramientas.

Si gustan expandir su conocimiento y mantenerse actualizados en cuenta a el uso de Groovy puede acceder a la página propia de Groovy https://groovy-lang.org/

De igual forma existen muchos «Cook Books» concernientes a la utilización de Groovy este podría ser el que pueden utilizar como punto de partida http://index-of.es/Varios-2/Groovy-Programming-Cookbook.pdf

Si tienen algun comentario o recomendacion eres totalmente libre de hacerlo, dejalo en los comentarios estare feliz de conversar con ustedes.

«El primer paso siempre a de ser el mas dificil.»

Suscribete a nuestras redes sociales:

TwitterLinkedinFacebook

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *