Empezando con Groovy

Instalación o Configuración

Hay dos formas comunes de instalar Groovy.

Descargar

El binario de Groovy se puede descargar en la página descargar del sitio web de Groovy. Puede descomprimir el archivo y agregar la ruta a %GROOVY_HOME%/bin/groovy.bat a la variable de entorno del sistema PATH, donde %GROOVY_HOME% es el directorio donde se descomprime Groovy.

SDKMAN

La otra opción es usar SDKMAN. Esta opción ha crecido rápidamente en popularidad y hace que administrar múltiples versiones de Groovy sea muy simple. También es compatible con otras aplicaciones en la ecosfera “GR8”. Esta opción funciona muy bien de forma nativa en Linux y Mac, pero requiere Cygwin en Windows.

Siguiendo las instrucciones de la página de descarga de Groovy, puede realizar los siguientes pasos para instalar SDKMAN.

$ curl -s get.sdkman.io | bash

Una vez que SDKMAN está instalado, ahora tiene acceso al comando sdk. Con este comando puedes hacer muchas cosas útiles.

Instalar Groovy

$ sdk instalar maravilloso

Esto instalará la última versión de Groovy.

Lista de versiones de Groovy

$ SDK ls Groovy

Esto le permite ejecutar un comando ls estilo Linux en el software Groovy, enumerando todas las opciones disponibles. Hay un * al lado de cada versión instalada y un > para indicar sus versiones actuales.

Cambiar versiones de Groovy

$ SDK usa Groovy 2.4.7

Esto cambiará la versión actual de Groovy a 2.4.7. Si tiene otras versiones instaladas, puede cambiar a cualquiera de ellas.

Puedes listar la versión actual de groovy con el comando groovy -version.

elegante-gvm

El nombre inicial de SDKMAN era GVM y posh-gvm es un puerto de GVM para Windows Powershell. Entonces, si desarrolla en una máquina con Windows y no quiere usar SDKMAN en Cygwin, posh-gvm es para usted. Funciona igual que SDKMAN, pero en lugar de sdk, el comando es gmv. Asi que

PS C:\Users\You> gmv install groovy

instalará groovy a través de posh-gvm en su máquina con Windows.

Hola mundo En maravilloso

El siguiente ejemplo ilustra el ‘Hello World’ más simple en groovy usando un script, coloque el siguiente fragmento de código en un archivo, diga ‘helloWorld.groovy’

println 'Hello World!'

Cómo ejecutar: En la línea de comando, groovy helloWorld.groovy

Producción: “¡Hola mundo!”

Usando Groovy en un proyecto Java

Groovy tiene acceso a todas las clases de Java, de hecho, las clases de Groovy SON clases de Java y la JVM puede ejecutarlas directamente. Si está trabajando en un proyecto Java, usar Groovy como un lenguaje de secuencias de comandos simple para interactuar con su código Java es una obviedad.

Para mejorar aún más las cosas, se puede cambiar el nombre de casi cualquier clase de Java a .groovy, compilarla y ejecutarla, y funcionará exactamente como lo hizo. Groovy está cerca de ser un superconjunto de Java, este es un objetivo declarado de Groovy.

Groovy tiene un REPL. groovysh viene con Groovy y se puede usar para instanciar y probar rápidamente una clase Java si su ruta de clases está configurada correctamente. Por ejemplo, si su classpath apuntaba a su directorio eclipse “classes/bin”, entonces podría guardar su archivo en eclipse, saltar a groovysh e instanciar la clase para probarla.

Las razones para usar Groovy para hacer esto en lugar de solo Java son: El cargador de clases es EXCELENTE para seleccionar nuevas clases a medida que se compilan. Por lo general, no necesita salir/reiniciar groovysh a medida que desarrolla.

La sintaxis es TERSA. Esto no es muy bueno para el código mantenible, pero para los scripts y las pruebas puede reducir significativamente el código. Una de las grandes cosas que hace es eliminar las excepciones comprobadas (o, más exactamente, convertir todas las excepciones comprobadas en excepciones no comprobadas). Esto convierte un código como este (Imprimir hola después de un segundo):

class JavaClass {
    public static void main(String[] args) {
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            // You shouldn't leave an empty catch block, but who cares if this was interrupted???
        }
        System.out.println("Hello!");
    }
}

en Groovy:

Thread.sleep(1000)
print "Hello!"

Groovy también tiene una sintaxis de inicialización muy estricta. Esto le permite especificar los datos tal como le gusta sin pensar en ello:

En Java, para inicializar un mapa, probablemente debería hacer algo como esto:

String[] init = { "1:Bill", "2:Doug", "3:Bev" };
// Note the rest of this can be put in a function and reused or maybe found in a library, but I always seem to have to write this function!
Map m = new HashMap<Integer, String>();
for(String pair : int) {
    String[] split = pair.split(":");
    m.put(new Integer(split[0]), split[1])
}

Esto no es malo, pero es otra cosa a mantener. En Groovy solo usarías:

Map map = { 1 : "Bill", 2 : "Doug", 3 : "Bev" }

Y ya está. La sintaxis de la lista es igual de fácil.

La otra gran ventaja es la sintaxis de cierre de Groovy. Es increíblemente conciso y divertido, algo más difícil de mantener, pero para los scripts eso no es una prioridad. Como ejemplo, aquí hay un código maravilloso para encontrar todos los archivos .txt que contienen la palabra Hola en el directorio actual:

println new File('.').files.findAll{ it.name.endsWith('.txt') && it.text.contains('Hello') }.collect{ it.name }

Este ejemplo utiliza algunos trucos “Groovy”:

  • .files se refiere al método getFiles() - groovy puede cambiar entre getter/setter y la sintaxis de propiedades a voluntad

  • it. se refiere al elemento actual de una iteración. { it } es un atajo para { it -> it }, p. :

    [1, 2, 3].collect{ it ^ 2 } == [1, 4, 9]

  • it.text (donde it es un archivo) usa un método que groovy agrega a File para recuperar el texto completo del archivo. Esto es increíblemente útil en los scripts.

Hola mundo Shebang (linux)

Dado un archivo hello.groovy con contenido:

#!/usr/bin/env groovy
println "Hello world"

Se puede ejecutar desde la línea de comando si se le da permiso de ejecución como

$ ./hello.groovy

Usando inyectar () en la lista para crear una cadena CSV

En Groovy, el método inject() es uno de los métodos acumulativos que nos permite agregar (o inyectar) nueva funcionalidad en cualquier objeto que implemente el método inject(). En el caso de una colección, podemos aplicar un cierre a una colección de objetos de manera uniforme y luego cotejar los resultados en un solo valor. El primer parámetro del método inject() es el valor inicial de la acumulación y el segundo parámetro es el cierre.

En este ejemplo, tomaremos una Lista de cadenas como parámetro y generaremos los valores de esas cadenas delimitadas por comas. He usado esta funcionalidad para agregar una lista de valores a una cadena de consulta REST y, si la modifica un poco, la he usado para incluir valores en una instrucción SQL como parte de una cláusula IN. Aquí está el código para hacer esto:

public String convertToCSV( List<String> list ) {
    if (list == null) {
        return ""
    }
    return list.inject( '' ) { result, item ->
        result + ( result && item ? ',' : '' ) + ( item ? "${item.trim()}" : '' )
    }
}

assert convertToCSV( null ) == ""
assert convertToCSV( ["aaa", "bbb  ", null, "  ccc  "] ) == "aaa,bbb,ccc" 

En este ejemplo, el primer parámetro del método inject() es una cadena de longitud cero, lo que significa que al procesar el primer elemento de la lista, el resultado también es una cadena de longitud cero. Esto se resuelve en falso en la primera evaluación ternaria, por lo que no obtenemos una coma al comienzo de la cadena. Con cada iteración consecutiva a través de los elementos de la lista, el resultado se convierte en la concatenación de sí mismo, una coma y luego el siguiente elemento hasta llegar al último elemento de la lista.

La ventaja de este enfoque es que no necesita una variable fuera de una construcción de bucle para contener el resultado de la cadena concatenada. La implicación es que esto puede provocar efectos secundarios en su código. Con el enfoque inject(), este comportamiento se inyecta y la colección recopila el resultado de las llamadas al cierre por usted. La desventaja de este enfoque puede ser la legibilidad. Pero con algo de experiencia, se vuelve más fácil de leer y comprender, y espero que este ejemplo te ayude a lograr ese objetivo.

Hola Mundo

La versión Groovy de Hello World.

println 'Hello World!'