Primeros pasos con gradle

¿Por qué gradle?

Al estilo de maven o ant, gradle es una herramienta más moderna pensada para automatizar todas las tareas que se hacen habitualmente en un proyecto software, como compilado, generar instalables, documentación, etc.

ant permite mucha versatilidad a cambio de que tengamos que definir nosotros todas las tareas a realizar y cómo hacerlas, lo que nos lleva a tener grandes ficheros de construcción de ant (ficheros build.xml) que pueden llegar a ser muy complejos. Maven, por el contrario, nos da prácticamente todo predefinido, por lo que si nos adaptamos a su forma de trabajo, los ficheros de construcción (ficheros pom.xml) no son demasiado complejos. La "pega" es que si lo predefinido por maven no nos vale, puede ser complejo alterar esa forma de trabajo.

Entre ambos mundos nace gradle. La idea de gradle es que cómo maven, nos de todo más o menos predefinido, de forma que sus ficheros de construcción (ficheros build.gradle) no sean demasiado complejos, pero por otro lado, dejándonos la posibilidad de modificar fácilmente este flujo de trabajo o tareas por defecto.

Veamos aquí cómo empezar a trabajar con gradle en un proyecto sencillo.

Instalar gradle

Gradle se instala simplemente bajando el zip de la página de gradle (nos vale el zip con los binarios). Desempaquetamos ese zip en un lugar de nuestro gusto, en mi caso por ejemplo, lo he hecho en el directorio C:\APLICACIONES, por lo que me ha quedado

C:\APLICACIONES\gradle-2.0

Ahora tenemos que poner el directorio C:\APLICACIONES\gradle-2.0\bin de gradle en el Path de ejecutables en Windows o del sistema operativo que usemos.

Una vez hecho y después de haberlo hecho, podemos abrir una ventana de comandos de windows y ejecutar gradle -version para ver que todo está funcionando correctamente. Deberíamos ver una salida como la siguiente

C:\Users\Javier>gradle -version

------------------------------------------------------------
Gradle 2.0
------------------------------------------------------------

Build time:   2014-07-01 07:45:34 UTC
Build number: none
Revision:     b6ead6fa452dfdadec484059191eb641d817226c

Groovy:       2.3.3
Ant:          Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM:          1.6.0_26 (Sun Microsystems Inc. 20.1-b02)
OS:           Windows 7 6.1 x86

C:\Users\Javier>

Crear un proyecto

A diferencia de maven, gradle no tiene un comando que nos permita crear un proyecto desde cero. Debemos saber qué directorios espera encontrar gradle y crearlos a mano. Por supuesto, gradle también permite que creemos los directorios como queramos y luego le indiquemos cuales son, pero la forma sencilla es crear los que él espera y así no hay que configurar nada.

Vamos a crear un pequeño proyecto java al estilo gradle. Los directorios a crear, serían:

• Por supuesto, un directorio para nuestro proyecto, donde metermos todo lo demás. En mi caso C:\PROYECTOS\ejemplo-gradle
• Gradle espera los fuentes java en el directorio src/main/java, que es el mismo directorio en el que los esperaría maven. Así que creamos C:\PROYECTOS\ejemplo-gradle\src\main\java
• Gradle espera los test de Junit en src/test/java, al igual que maven. Así que creamos el directorio C:\PROYECTOS\ejemplo-gradle\src\test\java
• Si hay ficheros de recursos que queramos que se incluyan dentro del jar de nuestro proyecto, debemos ponerlos en el directorio src\main\resources
• Si hay ficheros de recursos para los test, deben meterse en src\test\resources

Así que creamos src\main\java y metemos dentro un pequeño programa java, un HolaMundo.java, por supuesto, debajo del paquete que queramos, por ejemplo

src\main\java\com\chuidiang\ejemplos\gradle\HolaMundo.java

siendo com.chuidiang.ejemplos.gradle el package de nuestra clase HolaMundo.

Necesitamos en el directorio C:\PROYECTOS\ejemplo-gradle un fichero que le indique a gradle qué tipo de proyecto es. Creamos en ese directorio un fichero build.gradle, que es el nombre por defecto y cuyo contenido únicamente indica a gradle que es un proyecto java

apply plugin: 'java'

Listo, tenemos todo lo necesario de momento.

Crear el proyecto Eclipse

Gradle nos permite crear el proyecto para eclipse y para Idea. Veamos con eclipse. Basta con añadir en nuestro fichero build.gradle una línea indicando que queremos usar el plugin de eclipse.

apply plugin: 'java'
apply plugin: 'eclipse'

...

y ahora nos basta ejecutar el comando gradle eclipse para que se generen los ficheros propios de un proyecto eclipse (.project, .classpath y .settings). Ahora, abrimos eclipse, y sólo tenemos que importar un proyecto existente : "File"->"Import", "Existing project into workspace"->"next" y elegir el directorio de nuestro proyecto gradle.

Compilar el proyecto

Con todo esto construido, ejecutamos desde línea de comandos y en el directorio donde tenemos el fichero build.gradle (C:\PROYECTOS\ejemplo-gradle) el comando gradle build. La salida puede ser como la siguiente

C:\PROYECTOS\ejemplo-gradle>gradle build
:compileJava
:processResources UP-TO-DATE
:classes
:jar
:assemble
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE
:check UP-TO-DATE
:build

BUILD SUCCESSFUL

Total time: 20.38 secs

Ahí vemos todos los pasos que va dando gradle para compilar nuestro proyecto como compilar java, procesar los recursos, generar el jar, etc. Veremos también un mensaje indicando si ha habido éxito o ha ocurrido algún error. Como resultado de esto, se habrá creado debajo de nuestro proyecto un subdirectorio build con los resultados de todo este proceso.

• En build\classes estarán los .class de nuestro proyecto compilado
• en build\lib estará el ejemplo-gradle.jar generado de nuestro proyecto.

Dependencias

Nuestros test de JUnit, en el directorio src\test\java depdenden de la librería JUnit. Igualmente, nuestros fuentes de nuestro proyecto podrían depender de otras librerías externas, como log4j, hibernate, drivers de conexión a base de datos, apache commons, etc. En nuestro build.gradle podemos poner esas dependencias, pero debemos decirle a gradle donde encontrarlas.

Gradle es capaz de buscar dependencias en varios sitios, entre ellos, repositorios de librerías de ivy, de maven (como maven central) o incluso de un directorio dentro del proyecto donde tengamos esas librerías guardadas.

Para indicarle dónde buscar las librerías, dentro del fichero build.gradle debemos poner los repositorios que queremos usar. Sería algo parecido a esto

/* Para usar el repositorio central de maven */
repositories {
    mavenCentral()
}

/* Para usar un repositorio maven en otra URL que no sea la de maven central */
repositories {
    maven {
        url "http://repo.mycompany.com/maven2"
    }
}

/* Para usar el repositorio maven que tenemos en local en nuestro PC, si hemos
usado maven alguna vez */
repositories {
    mavenLocal()
}

/* Si tenemos las librerías en un directorio lib1 y lib2 debajo de nuestro proyecto,
es decir, C:\PROYECTOS\ejemplo-gradle\lib1 y C:\PROYECTOS\ejemplo-gradle\lib2
repositories {
    flatDir { dirs 'lib1' 'lib2' }
}

Entre las llaves de repositories podemos poner varios repositorios, incluso de distintos tipos, pudiendo tener así las librerías repartidas en varias ubicaciones.

Una vez indicado dónde buscar las dependencias, sólo debemos indicarle a gradle qué librerías queremos. Para ello usamos dependencies dentro del fichero build.gradle, de esta forma

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

Indicamos en primer lugar para qué necesitamos la librería. En este ejemplo hemos puesto compile para compilar nuestro proyecto y testCompile para indicar que se necesita esa librería para compilar los test de Junit. Obviamente, estas palabras compile y testCompile son propias del fichero gradle.properties y no nos las hemos inventado.

Luego, ponemos de cada librería el grupo (group), el nombre de la librería name y su versión version. En maven es práctica habitual identificar una librería por un grupo que de alguna forma "agrupa" todas las librerías relacionadas entre sí, un nombre y una versión. Si buscamos cualquier librería en maven central veremos una tabla de resultados en las que aparece en la primera columna el groupId (el grupo), en la segunda columna el artifactId (el nombre) y en la tercera columna la última versión disponible.

Con todo esto, nuestro fichero build.gradle quedaría así

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

Las dependencias se pueden poner en un formato más sencillo, juntando los tres parámetros (group, name y version) en una única cadena y separando por dos puntos, de esta forma

compile 'commons-collections:commons-collections:3.2'

En Gradle dependencies tienes montones de detalles sobre cómo manejar y poner las dependencias.

Ejecutar nuestro programa

Gradle permite ejecutar nuestro programa después de compilarlo e incluso generar un zip con todas las dependencias para poder distribuirlo más adelante. Para ello, en el fichero build.gradle debemos incluir el plugin application, una simple línea que podemos poner después de incluir el plugin de java

apply plugin: 'java'
apply plugin:'application'
...

Algo que debemos configurar, es indicarle a este plugin cual es la clase principal de nuestra aplicación, para ello, añadimos una línea más al fichero

apply plugin: 'java'
apply plugin:'application'

mainClassName = "com.chuidiang.ejemplos.gradle.HolaMundo"
...

y si no queremos más cosas raras, como parametros o propiedades en la línea de comandos de arranque de la máquina virtual, ya esta hecho todo lo necesario. El comando gradle run ejecutará nuestro programa

C:\PROYECTOS\ejemplo-gradle>gradle run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
Hola mundo

BUILD SUCCESSFUL

Total time: 27.072 secs

en el que vemos, antes de "BUILD SUCCESSFUL", la salida de nuestro programa "HolaMundo".

Generar un zip para distribuir

Usando el mismo plugin application, con el comando gradle distZip se genera un zip con nuestra aplicación, sus dependencias y unos scripts de arranque, para linux y windows

C:\PROYECTOS\ejemplo-gradle>gradle distZip
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:jar UP-TO-DATE
:startScripts UP-TO-DATE
:distZip UP-TO-DATE

BUILD SUCCESSFUL

Total time: 14.899 secs

Tras ejecutar el comando, en build\distributions tendremos nuestro fichero ejemplo-gradle.zip, que contiene dentro dos directorios : bin y lib. En bin estarán los scripts de arranque (el .bat y un script de linux) y en lib estarán los jar (nuestro jar y los jar de los que dependemos).