Gradle - Guía rápida

"Gradle is an open source build automation system"

Ant y Maven tuvieron un éxito considerable en el mercado JAVA. Ant fue la primera herramienta de compilación lanzada en 2000 y se desarrolla en base a la idea de programación procedimental. Más tarde se mejora con la capacidad de aceptar complementos y administración de dependencias a través de la red con la ayuda de Apache-IVY. El principal inconveniente es XML como formato para escribir scripts de compilación, ser jerárquico no es bueno para la programación procedimental y XML tiende a volverse inmanejable.

Maven se introdujo en 2004. Viene con muchas mejoras que ANT. Cambia su estructura y continúa usando XML para escribir especificaciones de construcción. Maven se basa en las convenciones y es capaz de descargar las dependencias a través de la red. Los principales beneficios de maven es su ciclo de vida. Mientras sigue el mismo ciclo de vida para múltiples proyectos de forma continua. Esto tiene un costo de flexibilidad. Maven también enfrenta algunos problemas en la gestión de la dependencia. No maneja bien los conflictos entre versiones de la misma biblioteca y los scripts de compilación personalizados complejos son en realidad más difíciles de escribir en maven que en ANT.

Finalmente, Gradle entró en escena en 2012. Gradle incluye algunas características eficientes de ambas herramientas.

Características de Gradle

La siguiente es la lista de funciones que proporciona Gradle.

• Declarative builds and build-by-convention- Gradle está disponible con lenguaje específico de dominio (DSL) independiente basado en el lenguaje Groovy. Gradle proporciona elementos de lenguaje declarativo. Estos elementos también brindan soporte de construcción por convención para Java, Groovy, OSGI, Web y Scala.

• Language for dependency based programming - El lenguaje declarativo se encuentra en la parte superior de un gráfico de tareas de propósito general, que puede aprovechar al máximo en su compilación.

• Structure your build- Gradle finalmente le permite aplicar principios de diseño comunes a su construcción. Le proporcionará una estructura perfecta para la construcción, de modo que pueda diseñar una construcción comprensible bien estructurada y de fácil mantenimiento.

• Deep API - El uso de esta API le permite monitorear y personalizar su configuración y comportamiento de ejecución en su núcleo.

• Gradle scales - Gradle puede aumentar fácilmente su productividad, desde compilaciones de proyectos simples y únicos hasta grandes compilaciones de proyectos múltiples empresariales.

• Multi-project builds- Gradle admite compilaciones de varios proyectos y admite compilaciones parciales. Si construye un subproyecto, Gradle se encarga de construir todos los subproyectos de los que depende.

• Different ways to manage your builds - Gradle admite diferentes estrategias para administrar sus dependencias.

• Gradle is the first build integration tool- Gradle es totalmente compatible con sus tareas ANT, Maven e infraestructura de repositorio lvy para publicar y recuperar dependencias. Gradle también proporciona un convertidor para convertir un pom.xml de Maven en un script de Gradle.

• Ease of migration- Gradle puede adaptarse fácilmente a cualquier estructura que tenga. Por lo tanto, siempre puede desarrollar su compilación de Gradle en la misma rama donde puede crear un script en vivo.

• Gradle Wrapper- Gradle Wrapper le permite ejecutar compilaciones de Gradle en máquinas donde Gradle no está instalado. Esto es útil para la integración continua de servidores.

• Free open source - Gradle es un proyecto de código abierto con licencia de Apache Software License (ASL).

• Groovy- El script de construcción de Gradle está escrito en Groovy. Todo el diseño de Gradle está orientado a ser utilizado como un lenguaje, no como un marco rígido. Y Groovy te permite escribir tu propio guión con algunas abstracciones. Toda la API de Gradle está completamente diseñada en lenguaje Groovy.

¿Por qué Groovy?

La API de Gradle completa está diseñada con el lenguaje Groovy. Esta es una ventaja de un DSL interno sobre XML. Gradle es una herramienta de construcción de propósito general en su esencia; su enfoque principal son los proyectos Java. En tales proyectos, los miembros del equipo estarán muy familiarizados con Java y es mejor que una compilación sea lo más transparente posible para todos los miembros del equipo.

Los lenguajes como Python, Groovy o Ruby son mejores para construir frameworks. La razón por la que se eligió Groovy es porque ofrece, con mucho, la mayor transparencia para las personas que usan Java. La sintaxis básica de Groovy es la misma que la de Java. Groovy ofrece mucho más además de eso.

Gradle es una herramienta de construcción basada en java. Hay algunos requisitos previos que deben instalarse antes de instalar el marco de trabajo Gradle.

Prerrequisitos

JDK y Groovy son los requisitos previos para la instalación de Gradle.

• Gradle requiere la instalación de JDK versión 6 o posterior en su sistema. Utiliza las bibliotecas JDK que están instaladas y configuradas en la variable de entorno JAVA_HOME.

• Gradle tiene su propia biblioteca Groovy, por lo tanto, no necesitamos instalar Groovy explícitamente. Si está instalado, Gradle lo ignora.

Los siguientes son los pasos para instalar Gradle en su sistema.

Paso 1: verificar la instalación de JAVA

En primer lugar, debe tener el kit de desarrollo de software Java (SDK) instalado en su sistema. Para verificar esto, ejecuteJava –version comando en cualquiera de las plataformas en las que está trabajando.

En Windows -

Ejecute el siguiente comando para verificar la instalación de Java. He instalado JDK 1.8 en mi sistema.

C:\> java -version

Salida -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

En Linux -

Ejecute el siguiente comando para verificar la instalación de Java. He instalado JDK 1.8 en mi sistema.

$ java - version

Salida -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Suponemos que los lectores de este tutorial tienen la versión 1.8.0_66 de Java SDK instalada en su sistema.

Paso 2: descarga el archivo de compilación de Gradle

Descargue la última versión de Gradle desde el enlace Descargar Gradle . En la página de referencia, haga clic en elComplete Distributionenlace. Este paso es común para cualquier plataforma. Para ello, obtendrá el archivo de distribución completo en su carpeta de Descargas.

Paso 3: configurar el entorno para Gradle

Configurar el entorno significa que tenemos que extraer el archivo de distribución, copiar los archivos de la biblioteca en la ubicación adecuada. ConfigurarGRADLE_HOME y PATH variables ambientales.

Este paso depende de la plataforma.

En Windows -

Extraiga el archivo zip descargado llamado gradle-2.11-all.zip y copie los archivos de distribución de Downloads\gradle-2.11\ a C:\gradle\ ubicación.

Después de eso, agregue el C:\gradle y C:\gradle\bin directorios al GRADLE_HOME y PATHvariables del sistema. Siga la instrucción dada que esright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Allí encontrará un cuadro de diálogo para crear y editar variables del sistema. Haga clic en el botón nuevo para crear la variable GRADLE_HOME (siga la captura de pantalla del lado izquierdo). Haga clic en Editar para editar la variable de sistema Path existente (siga la captura de pantalla del lado derecho). Siga las capturas de pantalla que se muestran a continuación.

En Linux -

Extraiga el archivo zip descargado llamado gradle-2.11-all.zip luego encontrará un archivo extraído llamado gradle-2.11.

Puede utilizar lo siguiente para mover los archivos de distribución de Downloads/gradle-2.11/ a /opt/gradle/ubicación. Ejecute esta operación desde el directorio de Descargas.

$ sudo mv gradle-2.11 /opt/gradle

Edite el archivo ~ / .bashrc, pegue el siguiente contenido y guárdelo.

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

Ejecute el siguiente comando para ejecutar ~/.bashrc archivo.

$ source ~/.bashrc

Paso 4: Verifica la instalación de Gradle

En ventanas:

Puede ejecutar el siguiente comando en el símbolo del sistema.

C:\> gradle –v

Salida: allí encontrarás la versión de Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

En Linux:

Puede ejecutar el siguiente comando en la terminal.

$ gradle –v

Salida: allí encontrarás la versión de Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle crea un archivo de script para manejar dos cosas; uno esprojects y otro es tasks. Cada compilación de Gradle representa uno o más proyectos. Un proyecto representa un JAR de biblioteca o una aplicación web o puede representar un ZIP que se ensambla a partir de los JAR producidos por otros proyectos. En pocas palabras, un proyecto se compone de diferentes tareas. Una tarea significa un trabajo que realiza una construcción. Una tarea puede ser compilar algunas clases, crear un JAR, generar Javadoc o publicar algunos archivos en un repositorio.

Usos de Gradle Groovy language para escribir guiones.

Escribir guión de compilación

Gradle proporciona un lenguaje específico de dominio (DSL) para describir compilaciones. Esto usa el lenguaje Groovy para facilitar la descripción de una construcción. Cada script de compilación de Gradle se codifica con UTF-8, se guarda fuera de línea y se denomina build.gradle.

build.gradle

Estamos describiendo tareas y proyectos utilizando un script Groovy. Puede ejecutar una compilación de Gradle con el comando de Gradle. Este comando busca un archivo llamadobuild.gradle. Eche un vistazo al siguiente ejemplo que representa un pequeño script que imprimetutorialspoint. Copie y guarde el siguiente script en un archivo llamadobuild.gradle. Este script de compilación define un nombre de tarea hola, que se utiliza para imprimir la cadena de puntos de tutoría.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script anterior. Debe ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

tutorialspoint

Si cree que la tarea funciona de manera similar al objetivo de ANT, entonces es correcto: la tarea de Gradle es equivalente al objetivo de ANT.

Puede simplificar esta tarea de saludo especificando un atajo (representa un símbolo <<) al doLastdeclaración. Si agrega este acceso directo a la tarea anteriorhello se verá como el siguiente script.

task hello << {
   println 'tutorialspoint'
}

Como lo anterior, puede ejecutar el script anterior usando gradle –q hello mando.

El guión de grado utilizó principalmente dos objetos reales, uno es el objeto del proyecto y otro es el objeto del guión.

Project Object- Cada guión describe uno o varios proyectos. Durante la ejecución, estos scripts configuran el objeto del proyecto. Puede llamar a algunos métodos y utilizar propiedades en su secuencia de comandos de compilación que se delegan al Objeto del proyecto.

Script Object- Gradle tomó el código de script en clases que implementan la interfaz de script y luego se ejecuta. Esto significa que todas las propiedades y métodos declarados por la interfaz del script están disponibles en su script.

La siguiente tabla define la lista de standard project properties. Todas estas propiedades están disponibles en su script de construcción.

Conceptos básicos de Groovy

Los scripts de compilación de Gradle utilizan la API Groovy completa. Como startup, eche un vistazo a los siguientes ejemplos.

El siguiente ejemplo explica cómo convertir una cadena a mayúsculas.

Copie y guarde el siguiente código en build.gradle archivo.

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debe ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q upper

Salida:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

El siguiente ejemplo explica cómo imprimir el valor de un parámetro implícito ($ it) 4 veces.

Copie y guarde el siguiente código en build.gradle archivo.

task count << {
   4.times { 
      print "$it " 
   }
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debe ejecutar esto, donde se almacena el archivo build.gradle.

$ gradle –q count

Salida:

0 1 2 3

El lenguaje Groovy proporciona muchas características en las que algunas características importantes se analizan a continuación.

Métodos Groovy JDK

Groovy agrega muchos métodos útiles a las clases estándar de Java. Por ejemplo, Iterable API de JDK implementa unaeach() método que itera sobre los elementos de la interfaz iterable.

Copie y guarde el siguiente código en build.gradle archivo.

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q groovyJDK

Salida:

M
a
r
c

Accesores de propiedad

Puede acceder automáticamente a los métodos getter y setter apropiados de una propiedad en particular especificando su referencia.

El siguiente fragmento define las sintaxis de los métodos getter y setter de una propiedad buildDir.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

Paréntesis opcionales en llamadas a métodos

Groovy contiene una característica especial en las llamadas a métodos que es que los paréntesis son opcionales para las llamadas a métodos. Esta función también se aplica a las secuencias de comandos de Gradle.

Eche un vistazo a la siguiente sintaxis. Eso define un método llamandosystemProperty de test objeto.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

El cierre como último parámetro del método

Gradle DSL usa cierres en muchos lugares. Donde el último parámetro de un método es un cierre, puede colocar el cierre después de la llamada al método.

El siguiente fragmento define las sintaxis que los cierres usan como parámetros del método repositories ().

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

Importaciones predeterminadas

Gradle agrega automáticamente un conjunto de declaraciones de importación a los scripts de Gradle. La siguiente lista muestra los paquetes de importación predeterminados al script de Gradle.

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

El script de compilación de Gradle describe uno o más proyectos. Cada proyecto se compone de diferentes tareas. Una tarea es un trabajo que realiza una construcción. La tarea puede consistir en compilar algunas clases, almacenar archivos de clases en una carpeta de destino separada, crear JAR, generar Javadoc o publicar algunos logros en repositorios.

Este capítulo explica qué es una tarea y cómo generar y ejecutar una tarea.

Definición de tareas

Tarea es una palabra clave que se utiliza para definir una tarea en un script de construcción. Eche un vistazo al siguiente ejemplo que representa una tarea llamadahello que imprime tutorialspoint. Copie y guarde el siguiente script en un archivo llamadobuild.gradle. Este script de construcción define un nombre de tarea hola que se utiliza para imprimir la cadena de puntos de tutoría.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script anterior. Debe ejecutar esto donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

tutorialspoint

Puede simplificar esta tarea de saludo especificando un atajo (representa un símbolo <<) al doLastdeclaración. Si agrega este acceso directo a la tarea anteriorhello se verá como el siguiente script.

task hello << {
   println 'tutorialspoint'
}

Puede ejecutar el script anterior usando gradle –q hello mando.

Aquí hay algunas variaciones en la definición de una tarea, échale un vistazo. El siguiente ejemplo define una tareahello.

Copie y guarde el siguiente código en build.gradle archivo.

task (hello) << {
   println "tutorialspoint"
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

tutorialspoint

También puede utilizar cadenas para los nombres de las tareas. Eche un vistazo al mismo ejemplo de saludo. Aquí usaremos String como tarea.

Copie y guarde el siguiente código en build.gradle archivo.

task('hello') << {
   println "tutorialspoint"
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

tutorialspoint

También puede utilizar una sintaxis alternativa para definir una tarea. Eso es usar el método create () para definir una tarea. Eche un vistazo al mismo ejemplo de saludo que se muestra a continuación.

Copie y guarde el siguiente código en build.gradle archivo.

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

tutorialspoint

Localización de tareas

Si desea ubicar las tareas que definió en el archivo de compilación, debe usar las propiedades estándar del proyecto respectivas. Eso significa que cada tarea está disponible como una propiedad del proyecto, utilizando el nombre de la tarea como el nombre de la propiedad.

Eche un vistazo al siguiente código que accede a las tareas como propiedades.

Copie y guarde el siguiente código en build.gradle archivo.

task hello

println hello.name
println project.hello.name

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

hello
hello

También puede utilizar todas las propiedades a través de la colección de tareas.

Copie y guarde el siguiente código en build.gradle archivo.

task hello

println tasks.hello.name
println tasks['hello'].name

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

hello
hello

También puede acceder a la ruta de la tarea utilizando las tareas. Para ello, puede llamar al método getByPath () con un nombre de tarea, una ruta relativa o una ruta absoluta.

Copie y guarde el siguiente código en build.gradle archivo.

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde se almacena el archivo build.gradle.

C:\> gradle –q hello

Salida:

:hello
:hello
:projectA:hello
:projectA:hello

Agregar dependencias a las tareas

Puede hacer que una tarea dependa de otra tarea, lo que significa que cuando se realiza una tarea, solo se iniciará otra. Cada tarea se diferencia con el nombre de la tarea. La colección de nombres de tareas se refiere a su colección de tareas. Para hacer referencia a una tarea en otro proyecto, debe utilizar la ruta del proyecto como prefijo para el nombre de la tarea correspondiente.

El siguiente ejemplo que agrega una dependencia de taskX a taskY.

Copie y guarde el siguiente código en build.gradlearchivo. Eche un vistazo al siguiente código.

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde elbuild.gradle almacenes de archivos.

C:\> gradle –q taskY

Salida:

taskX
taskY

El ejemplo anterior agrega dependencia a la tarea usando sus nombres. Hay otra forma de lograr la dependencia de tareas que es definir la dependencia mediante un objeto Task.

Tomemos el mismo ejemplo de taskY que depende de taskX pero estamos usando objetos de tarea en lugar de nombres de referencia de tareas.

Copie y guarde el siguiente código en build.gradle archivo.

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

Ejecute el siguiente comando en el símbolo del sistema. Debe ejecutar esto donde se almacena el archivo build.gradle.

C:\> gradle –q taskY

Salida:

taskX
taskY

El ejemplo anterior agrega dependencia a la tarea usando sus nombres. Hay otra forma de lograr la dependencia de la tarea que es definir la dependencia mediante un objeto Task.

Aquí tomamos el mismo ejemplo de que taskY depende de taskX pero estamos usando objetos de tarea en lugar de nombres de referencias de tareas. Échale un vistazo.

Copie y guarde el siguiente código en build.gradlearchivo. Eche un vistazo al siguiente código.

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

Ejecute el siguiente comando en el símbolo del sistema. Ejecuta el script dado arriba. Debería ejecutar esto, donde elbuild.gradle almacenes de archivos.

C:\> gradle –q taskX

Salida:

lib1
lib2
taskX

Agregar una descripción a una tarea

Puede agregar una descripción a su tarea. Esta descripción se muestra al ejecutarGradle tasks. Esto es posible mediante el uso de la palabra clave descripción.

Copie y guarde el siguiente código en build.gradlearchivo. Eche un vistazo al siguiente código.

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

Ejecute el siguiente comando en el símbolo del sistema. Debe ejecutar esto donde se almacena el archivo build.gradle.

C:\> gradle –q copy

Si el comando se ejecuta correctamente, obtendrá el siguiente resultado.

description applied

Saltarse tareas

Se pueden omitir tareas pasando un cierre de predicado. Esto es posible solo si el método de una tarea o un cierre arrojando unStopExecutionException antes de que se ejecute el trabajo real de una tarea.

Copie y guarde el siguiente código en build.gradle archivo.

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

Ejecute el siguiente comando en el símbolo del sistema. Debe ejecutar esto donde se almacena el archivo build.gradle.

C:\> gradle –q eclipse

Estructura de tareas

Gradle tiene diferentes fases cuando se trabaja con tareas. En primer lugar, hay una fase de configuración, donde se ejecuta el código, que se especifica directamente en el cierre de una tarea. El bloque de configuración se ejecuta para cada tarea disponible y no solo para aquellas tareas que se ejecutan posteriormente.

Después de la fase de configuración, la fase de ejecución ejecuta el código dentro del doFirst o doLast cierres de esas tareas, que realmente se ejecutan.

El script de construcción de Gradle define un proceso para construir proyectos; cada proyecto contiene algunas dependencias y algunas publicaciones. Las dependencias son las cosas que apoyan la construcción de su proyecto, como el archivo JAR requerido de otros proyectos y los archivos JAR externos como JDBC JAR o Eh-cache JAR en la ruta de clases. Publicaciones significa los resultados del proyecto, como archivos de clases de prueba y archivos de compilación, como archivos war.

La mayoría de los proyectos no son autónomos. Necesitan archivos creados por otros proyectos para compilar y probar los archivos fuente. Por ejemplo, para usar Hibernate en el proyecto, necesita incluir algunos JAR de Hibernate en la ruta de clases. Gradle usa un script especial para definir las dependencias, que deben descargarse.

Gradle se encarga de crear y publicar los resultados en algún lugar. La publicación se basa en la tarea que defina. Es posible que desee copiar los archivos al directorio local o cargarlos en un repositorio remoto de Maven o lvy, o puede usar los archivos de otro proyecto en la misma compilación multiproyecto. Podemos llamar publicación al proceso de publicación de una tarea.

Declaración de sus dependencias

La configuración de dependencias no es más que define un conjunto de dependencias. Puede utilizar esta función para declarar medios de dependencias externas que desea descargar de la web. Esto define diferentes standers como sigue.

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Configuraciones de dependencia

La configuración de dependencias no es más que define un conjunto de dependencias. Puede utilizar esta función para declarar dependencias externas, que desea descargar de la web. Esto define las siguientes configuraciones estándar diferentes.

• Compile - Las dependencias necesarias para compilar la fuente de producción del proyecto.

• Runtime- Las dependencias requeridas por las clases de producción en tiempo de ejecución. De forma predeterminada, también incluye las dependencias de tiempo de compilación.

• Test Compile- Las dependencias necesarias para compilar la fuente de prueba del proyecto. De forma predeterminada, incluye clases de producción compiladas y las dependencias de tiempo de compilación.

• Test Runtime- Las dependencias necesarias para ejecutar las pruebas. De forma predeterminada, incluye dependencias de compilación de pruebas y tiempo de ejecución.

Dependencias externas

Las dependencias externas son las del tipo de dependencias. Esta es una dependencia de algunos archivos creados fuera de la compilación actual y almacenados en un repositorio de algún tipo, como Maven central, o un repositorio corporativo de Maven o lvy, o un directorio del sistema de archivos local.

El siguiente fragmento de código es para definir la dependencia externa. Utilice este código enbuild.gradle archivo.

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

Una dependencia externa está declarando dependencias externas y el formulario de acceso directo se parece a "grupo: nombre: versión".

Repositorios

Al agregar dependencias externas. Gradle los busca en un repositorio. Un repositorio es solo una colección de archivos, organizados por grupo, nombre y versión. De forma predeterminada, Gradle no define ningún repositorio. Tenemos que definir al menos un repositorio de forma explícita. El siguiente fragmento de código define cómo definir el repositorio de maven. Utilice este código enbuild.gradle archivo.

repositories {
   mavenCentral()
}

El siguiente código es para definir maven remoto. Utilice este código enbuild.gradle archivo.

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

Publicar artefactos

Las configuraciones de dependencia también se utilizan para publicar archivos. Estos archivos publicados se denominan artefactos. Por lo general, usamos complementos para definir artefactos. Sin embargo, debe indicarle a Gradle dónde publicar los artefactos. Puede lograr esto adjuntando repositorios a la tarea de carga de archivos. Eche un vistazo a la siguiente sintaxis para publicar el repositorio de Maven. Mientras se ejecuta, Gradle generará y cargará un Pom.xml según los requisitos del proyecto. Utilice este código enbuild.gradle archivo.

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

El complemento no es más que un conjunto de tareas, casi todas las tareas útiles, como compilar tareas, configurar objetos de dominio, configurar archivos de origen, etc., son manejadas por complementos. Aplicar un complemento a un proyecto significa que permite que el complemento amplíe las capacidades del proyecto. Los complementos pueden hacer cosas como:

• Amplíe el modelo básico de Gradle (por ejemplo, agregue nuevos elementos DSL que se puedan configurar).
• Configure el proyecto de acuerdo con las conversiones (por ejemplo, agregue nuevas tareas o configure valores predeterminados sensibles).
• Aplicar una configuración específica (por ejemplo, agregar repositorios organizacionales o hacer cumplir los estándares).

Tipos de complementos

Hay dos tipos de complementos en Gradle, complementos de script y complementos binarios. Los complementos de script son un script de compilación adicional que brinda un enfoque declarativo para manipular la compilación. Esto se usa típicamente dentro de una compilación. Los complementos binarios son las clases que implementan la interfaz del complemento y adoptan un enfoque programático para manipular la compilación. Los complementos binarios pueden residir con un script de compilación, con la jerarquía del proyecto o externamente en un JAR de complemento.

Aplicación de complementos

Project.apply()El método API se utiliza para aplicar el complemento en particular. Puede utilizar el mismo complemento varias veces. Hay dos tipos de complementos, uno es un complemento de script y el segundo es un complemento binario.

Complementos de secuencias de comandos

Los complementos de secuencias de comandos se pueden aplicar desde una secuencia de comandos en el sistema de archivos local o en una ubicación remota. Las ubicaciones del sistema de archivos son relativas al directorio del proyecto, mientras que las ubicaciones de los scripts remotos especifican la URL HTTP. Eche un vistazo al siguiente fragmento de código. Se utiliza para aplicar elother.gradlecomplemento al script de compilación. Utilice este código enbuild.gradle archivo.

apply from: 'other.gradle'

Complementos binarios

Cada complemento se identifica por la identificación del complemento en aquellos que algunos complementos principales usan nombres cortos para aplicarlo y algunos complementos de la comunidad usan un nombre completo para la identificación del complemento. En algún momento permite especificar la clase de complemento.

Eche un vistazo al siguiente fragmento de código. Muestra cómo aplicar el complemento de Java utilizando su tipo. Utilice este código enbuild.gradle archivo.

apply plugin: JavaPlugin

Eche un vistazo al siguiente código para aplicar el complemento principal con un nombre corto. Utilice este código enbuild.gradle archivo.

plugins {
   id 'java'
}

Eche un vistazo al siguiente código para aplicar el complemento de la comunidad con un nombre corto. Utilice este código enbuild.gradle archivo.

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

Escribir complementos personalizados

Al crear un complemento personalizado, debe escribir una implementación del complemento. Gradle crea una instancia del complemento y llama a la instancia del complemento mediante el método Plugin.apply (). El siguiente ejemplo contiene un complemento de saludo, que agrega una tarea de saludo al proyecto. Eche un vistazo al siguiente código. Utilice este código enbuild.gradle archivo.

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

Utilice el siguiente código para ejecutar el script anterior.

C:\> gradle -q hello

Salida:

Hello from the GreetingPlugin

Obtener información de la compilación

La mayoría de los complementos necesitan el soporte de configuración del script de compilación. El proyecto Gradle tiene un objeto ExtensionContainer asociado que ayuda a rastrear todas las configuraciones y propiedades que se pasan a los complementos.

Agreguemos un objeto de extensión simple al proyecto. Aquí agregamos un objeto de extensión de saludo al proyecto, que le permite configurar el saludo. Utilice este código enbuild.gradle archivo.

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

Utilice el siguiente código para ejecutar el script anterior.

C:\> gradle -q hello

Salida:

Hi from Gradle

En este ejemplo, GreetingPlugin es un viejo objeto Groovy con un campo llamado mensaje. El objeto de extensión se agrega a la lista de complementos con el nombre saludo. Este objeto pasa a estar disponible como una propiedad de proyecto con el mismo nombre que el objeto de extensión.

Gradle agrega un cierre de configuración para cada objeto de extensión, por lo que puede agrupar las configuraciones. Eche un vistazo al siguiente código. Utilice este código enbuild.gradle archivo.

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

Utilice el siguiente código para ejecutar el script anterior.

C:\> gradle -q hello

Salida:

Hello from Gradle

Complementos estándar de Gradle

Hay diferentes complementos que se incluyen en la distribución de Gradle.

Complementos de idioma

Estos complementos agregan soporte para varios lenguajes que se pueden compilar y ejecutar en la JVM.

Incubación de complementos de idioma

Estos complementos añaden soporte para varios idiomas.

Gradle proporciona una línea de comandos para ejecutar un script de compilación. Puede ejecutar más de una tarea a la vez. Este capítulo explica cómo ejecutar múltiples tareas usando diferentes opciones.

Ejecución de varias tareas

Puede ejecutar varias tareas desde un solo archivo de compilación. Gradle puede manejar ese archivo de compilación usandogradle command. Este comando compilará cada tarea en el orden en que se enumeran y ejecutará cada tarea junto con las dependencias utilizando diferentes opciones.

Example- Hay cuatro tareas: tarea1, tarea2, tarea3 y tarea4. Task3 y task4 dependen de la tarea 1 y la tarea2. Eche un vistazo al siguiente diagrama.

En lo anterior, 4 tareas dependen unas de otras representadas con un símbolo de flecha. Eche un vistazo al siguiente código. Copiar puede pegarlo enbuild.gradle archivo.

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

Puede utilizar el siguiente código para compilar y ejecutar la tarea anterior.

C:\> gradle task4 test

Salida:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Excluyendo tareas

Mientras excluye una tarea de la ejecución, puede usar la opción –x junto con el comando gradle y mencionar el nombre de la tarea que desea excluir.

Utilice el siguiente comando para excluir task4 del script anterior.

C:\> gradle task4 -x test

Salida:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Continuación de la construcción cuando ocurre una falla

Gradle abortará la ejecución y fallará la compilación tan pronto como falle cualquier tarea. Puede continuar la ejecución incluso cuando se produce una falla. Para esto tienes que usar la opción –continuar con el comando gradle. Maneja cada tarea por separado junto con sus dependencias. Y el principal punto importante es que detectará cada falla encontrada e informará al final de la ejecución de la compilación. Suponga que si una tarea falla, las tareas subsiguientes dependientes tampoco se ejecutarán.

Seleccionar qué compilación ejecutar

Cuando ejecuta el comando gradle, busca un archivo de compilación en el directorio actual. Puede usar la opción –b para seleccionar un archivo de construcción particular junto con la ruta absoluta. El siguiente ejemplo seleccionando un proyecto hola demyproject.gradle archivo que se encuentra en el subdir/ échale un vistazo.

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

Puede utilizar el siguiente comando para ejecutar el script anterior.

C:\> gradle -q -b subdir/myproject.gradle hello

Salida:

using build file 'myproject.gradle' in 'subdir'.

Obtención de información de compilación

Gradle proporciona varias tareas integradas para recuperar los detalles de la información sobre la tarea y el proyecto. Esto puede ser útil para comprender la estructura y las dependencias de su compilación y para depurar problemas. Puede usar el complemento de informes del proyecto para agregar tareas a su proyecto, que generarán estos informes.

Listado de proyectos

Puede enumerar la jerarquía de proyectos del proyecto seleccionado y sus subproyectos utilizando gradle –q projectsmando. Aquí está el ejemplo, use el siguiente comando para listar todo el proyecto en el archivo de construcción.

C:\> gradle -q projects

Salida:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

El informe muestra la descripción de cada proyecto si se especifica. Puede utilizar el siguiente comando para especificar la descripción. Pégalo en elbuild.gradle archivo.

description = 'The shared API for the application'

Listado de tareas

Puede enumerar todas las tareas que pertenecen a los múltiples proyectos usando el siguiente comando.

C:\> gradle -q tasks

Salida:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

Puede utilizar el siguiente comando para mostrar la información de todas las tareas.

C:\> gradle -q tasks --all

Salida:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

Aquí hay una lista de comandos en una tabla de descripción de diferentes opciones.

Este capítulo explica cómo construir un proyecto java usando el archivo de compilación de Gradle.

En primer lugar, tenemos que agregar el complemento java al script de compilación porque proporciona tareas para compilar el código fuente de Java, ejecutar pruebas unitarias, crear Javadoc y crear un archivo JAR. Utilice la siguiente línea enbuild.gradle archivo.

apply plugin: 'java'

Diseño de proyecto predeterminado de Java

Cada vez que agrega un complemento a su compilación, se asume una cierta configuración de su proyecto Java (similar a Maven). eche un vistazo a la siguiente estructura de directorio.

• src / main / java contiene el código fuente de Java
• src / test / java contiene las pruebas de Java

Si sigue esta configuración, el siguiente archivo de compilación es suficiente para compilar, probar y empaquetar un proyecto Java.

Para iniciar la compilación, escriba el siguiente comando en la línea de comandos.

C:\> gradle build

SourceSetsse puede utilizar para especificar una estructura de proyecto diferente. Por ejemplo, las fuentes se almacenan en unsrc carpeta en lugar de en src/main/java. Eche un vistazo a la siguiente estructura de directorios.

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

Ejecución de tareas init

Gradle aún no admite varias plantillas de proyectos. Pero ofrece unainittarea para crear la estructura de un nuevo proyecto de Gradle. Sin parámetros adicionales, esta tarea crea un proyecto de Gradle, que contiene los archivos de envoltura de Gradle, unbuild.gradle y settings.gradle archivo.

Al agregar el --type parámetro con java-library como valor, se crea una estructura de proyecto java y el build.gradleEl archivo contiene una determinada plantilla Java con Junit. Eche un vistazo al siguiente código parabuild.gradle archivo.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

En la sección de repositorios, define dónde encontrar las dependencias. Jcenteres para resolver sus dependencias. La sección de dependencias es para proporcionar información sobre dependencias externas.

Especificación de la versión de Java

Por lo general, un proyecto Java tiene una versión y un JRE de destino en el que se compila. losversion y sourceCompatibility La propiedad se puede establecer en el build.gradle archivo.

version = 0.1.0
sourceCompatibility = 1.8

Si el artefacto es una aplicación Java ejecutable, el MANIFEST.MF El archivo debe ser consciente de la clase con el método principal.

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

Cree una estructura de directorio como se muestra en la siguiente captura de pantalla.

Copie el código java que se proporciona a continuación en el archivo App.java y guárdelo en consumerbanking\src\main\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Copie el código java proporcionado a continuación en el archivo AppTset.java y guárdelo en consumerbanking\src\test\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Copie el código dado a continuación en el archivo build.gradle y colóquelo en consumerbanking\ directorio.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Para compilar y ejecutar el script anterior, utilice los comandos que se indican a continuación.

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

Verifique todos los archivos de clase en los directorios respectivos y verifique consumerbanking\build\lib carpeta para consumerbanking.jar archivo.

Este capítulo explica cómo compilar y ejecutar un proyecto Groovy usando build.gradle archivo.

El complemento Groovy

El complemento Groovy para Gradle amplía el complemento Java y proporciona tareas para los programas Groovy. Puede usar la siguiente línea para aplicar el complemento maravilloso.

apply plugin: 'groovy'

El archivo de script de compilación completo es el siguiente. Copie el siguiente código enbuild.gradle archivo.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

Puede utilizar el siguiente comando para ejecutar el script de compilación.

gradle build

Diseño de proyecto predeterminado de proyectos Groovy

El complemento Groovy asume una cierta configuración de su proyecto Groovy.

• src / main / groovy contiene el código fuente de Groovy
• src / test / groovy contiene las pruebas Groovy
• src / main / java contiene el código fuente de Java
• src / test / java contiene las pruebas de Java

Consulte el directorio respectivo donde build.gradle lugares de archivo para la carpeta de compilación.

La tarea de prueba detecta y ejecuta automáticamente todas las pruebas unitarias en el conjunto fuente de prueba. También genera un informe una vez que se completa la ejecución de la prueba. JUnit y TestNG son las API compatibles.

La tarea de prueba proporciona una Test.getDebug()método que se puede configurar para que se inicie para hacer que la JVM espere un depurador. Antes de continuar con la ejecución, establece la publicación del depurador en5005.

Prueba de detección

los Test Taskdetecta qué clases son clases de prueba inspeccionando las clases de prueba compiladas. De forma predeterminada, analiza todos los archivos .class. Puede establecer inclusiones / exclusiones personalizadas, solo se escanearán esas clases. Dependiendo del marco de prueba utilizado (JUnit / TestNG), la detección de la clase de prueba utiliza diferentes criterios.

Cuando usamos JUnit, buscamos clases de prueba de JUnit 3 y 4. Si alguno de los siguientes criterios coincide, la clase se considera una clase de prueba JUnit:

• Clase o una superclase extiende TestCase o GroovyTestCase
• La clase o superclase se anota con @RunWith
• La clase o una superclase contienen un método anotado con @Test
• Cuando usamos TestNG, buscamos métodos anotados con @Test

Note- Las clases abstractas no se ejecutan. Gradle también escanea el árbol de herencia en archivos jar en la ruta de clases de prueba.

Si no desea utilizar la detección de clases de prueba, puede deshabilitarla configurando scanForTestClasses a falso.

Prueba de agrupación

JUnit y TestNG permiten agrupaciones sofisticadas de métodos de prueba. Para agrupar, clases de prueba JUnit y métodos JUnit 4.8 introduce el concepto de categorías. La tarea de prueba permite la especificación de las categorías JUnit que desea incluir y excluir.

Puede utilizar el siguiente fragmento de código en el archivo build.gradle para agrupar métodos de prueba.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Incluir y excluir pruebas particulares

los Test la clase tiene un include y excludemétodo. Estos métodos se pueden utilizar para especificar qué pruebas deben ejecutarse realmente.

Ejecute solo las pruebas incluidas:

test {
   include '**my.package.name/*'
}

Omitir pruebas excluidas -

test {
   exclude '**my.package.name/*'
}

La muestra build.gradle archivo como se muestra a continuación, muestra diferentes opciones de configuración.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Puede utilizar la siguiente sintaxis de comando para ejecutar alguna tarea de prueba.

gradle <someTestTask> --debug-jvm

Gradle puede manejar fácilmente los proyectos más pequeños y más grandes. Los proyectos pequeños tienen un solo archivo de compilación y un árbol de fuentes. Es muy fácil de digerir y comprender un proyecto que se ha dividido en módulos más pequeños e interdependientes. Gradle soporta perfectamente este escenario que es compilación multiproyecto.

Estructura para compilación multiproyecto

Estas construcciones vienen en todas las formas y tamaños, pero tienen algunas características en común:

• UN settings.gradle archivo en el directorio raíz o maestro del proyecto.

• UN build.gradle archivo en el directorio raíz o maestro.

• Directorios secundarios que tienen sus propios *.gradle archivos de compilación (algunas compilaciones multiproyecto pueden omitir los scripts de compilación de proyectos secundarios).

Para enumerar todos los proyectos en el archivo de compilación, puede usar el siguiente comando.

C:\> gradle -q projects

Salida:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

El informe muestra la descripción de cada proyecto, si se especifica. Puede utilizar el siguiente comando para especificar la descripción. Pégalo en elbuild.gradle archivo.

description = 'The shared API for the application'

Especificación de una configuración de compilación general

en un build.gradle en root_project, las configuraciones generales se pueden aplicar a todos los proyectos o solo a los subproyectos.

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

Esto especifica un común com.example.gradle grupo y el 0.1.0versión para todos los proyectos. lossubprojects El cierre aplica configuraciones comunes para todos los subproyectos, pero no para el proyecto raíz, como el allprojects el cierre lo hace.

Configuraciones y dependencias específicas del proyecto

El núcleo ui y util Los subproyectos también pueden tener sus propios build.gradle archivo, si tienen necesidades específicas, que aún no están aplicadas por la configuración general del proyecto raíz.

Por ejemplo, el proyecto de interfaz de usuario generalmente tiene una dependencia del proyecto principal. Entonces el proyecto de interfaz de usuario necesita su propiobuild.gradle archivo para especificar esta dependencia.

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

Las dependencias del proyecto se especifican con el método del proyecto.

Gradle ofrece varias formas de implementar repositorios de artefactos de compilación. Al implementar firmas para sus artefactos en un repositorio de Maven, también querrá firmar el archivo POM publicado.

Uso del complemento de publicación de Maven

maven-publishcomplemento, que proporciona Gradle de forma predeterminada. Se usa para publicar el guión de Gradle. Eche un vistazo al siguiente código.

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

Hay varias opciones de publicación, cuando el Java y el maven-publishse aplica el complemento. Eche un vistazo al siguiente código, implementará el proyecto en un repositorio remoto.

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

Conversión de un proyecto de Maven a Gradle

Hay un comando especial para convertir Apache Maven pom.xml archivos a archivos de compilación de Gradle, si todos los complementos de Maven utilizados son conocidos para esta tarea.

En esta sección lo siguiente pom.xmlLa configuración de maven se convertirá en un proyecto de Gradle. Échale un vistazo.

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

Puede usar el siguiente comando en la línea de comandos que da como resultado la siguiente configuración de Gradle.

C:\> gradle init --type pom

los init La tarea depende de la tarea de contenedor para que se cree un contenedor de Gradle.

La resultante build.gradle archivo se parece a esto -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

Este capítulo explica la integración de eclipse y Gradle. Siga los pasos que se indican a continuación para agregar el complemento de Gradle a eclipse.

Paso 1: Abra Eclipse Marketplace

En primer lugar, abra el eclipse que está instalado en su sistema. Vaya a ayuda -> haga clic en EclipseMarketplace. Eche un vistazo a la siguiente captura de pantalla.

Paso 2: instalar el complemento Buildship

Después de hacer clic en Eclipse Marketplace, encontrará la siguiente captura de pantalla. Aquí, en la barra de búsqueda del lado izquierdo, escribabuildship. Buildship es un complemento de integración de Gradle. Cuando encuentre la construcción en su pantalla, haga clic en instalar en el lado derecho. Eche un vistazo a la siguiente captura de pantalla.

Después de eso, encontrará la siguiente captura de pantalla, allí debe confirmar la instalación del software haciendo clic en el botón confirmar. Eche un vistazo a la siguiente captura de pantalla.

Después de eso, debe hacer clic en aceptar acuerdo de licencia en la siguiente pantalla y hacer clic en finalizar. Eche un vistazo a la siguiente captura de pantalla.

La instalación llevará algún tiempo. Eche un vistazo a la siguiente captura de pantalla.

Después de eso, le pedirá que reinicie Eclipse. Allí seleccionarásYes.

Paso 3: verificar el complemento de Gradle

Mientras verificamos, crearemos un nuevo proyecto siguiendo el procedimiento dado. En el eclipse, vaya al archivo -> haga clic en nuevo-> haga clic en otros proyectos. Allí encontrará la siguiente pantalla. Allí, seleccione el proyecto Gradle y haga clic en siguiente. Eche un vistazo a la siguiente captura de pantalla.

Después de hacer clic en el botón siguiente, encontrará la siguiente pantalla. Allí proporcionará la ruta del directorio de inicio de Gradle del sistema de archivos local y haga clic en el botón Siguiente. Eche un vistazo a la siguiente captura de pantalla.

Eche un vistazo a la siguiente captura de pantalla, aquí proporcionará el nombre del proyecto Gradle. En este tutorial estamos usandodemoproject y haga clic en el botón Finalizar.

Eche un vistazo a la siguiente captura de pantalla que necesitamos para confirmar el proyecto. Para eso, hacemos clic en el botón finalizar en la siguiente pantalla.

Paso 4: verificación de la estructura del directorio

Después de la instalación exitosa del complemento Gradle, verifique la estructura del directorio del proyecto de demostración para los archivos y carpetas predeterminados como se muestra en la siguiente captura de pantalla.