Overview
Terminología
https://docs.gradle.org/current/userguide/what_is_gradle.html#terminology
Projects
Los Projects son las cosas que Gradle construye (build). Los proyectos contienen un build script, llamado build.gradle, que se ubica en el
directorio raiz del proyecto. Los build scripts definen tasks, dependencies, plugins y otras configuraciones. Un único build
puede contener uno o más proyectos y cada proyecto puede tener sus propios subproyectos.
Tasks
Las tasks contienen las instrucciones (código) para ejecutar cierto trabajo: compliar código, ejecutar tests o desplegar aplicaciones. En la mayoría de casos
se utilizan tareas preexistentes, aunque es posible programar tus propias tareas. Gradle proporciona tareas que implementan las tareas más comunes, y los plugins proporcionan
incluso más tipos de tareas.
Las tareas consisten en:
- Actions: instrucciones que hacen algo, como copiar ficheros o compilar código
- Inputs: valores, ficheros y directorios sobre los cuales operan las acciones
- Outputs: ficheros y directorios que las acciones modifican o generan
Plugins
Gradle en su esencia proporciona intencionalmente muy poco para la automatización del mundo real. Todas las características útiles, como la capacidad de
compilar código Java, se agregan mediante complementos. Los complementos agregan nuevas tareas (p. ej., JavaCompile), objetos de dominio (p. ej., SourceSet),
convenciones (p. ej., la fuente de Java se encuentra en src/main/java), además de ampliar los objetos principales y los objetos de otros complementos.
Build Fases
Gradle ejecuta los build scripts en tres fases, conocidas como Build lifecycle:
Inicialización: configura el entorno y usa el fichero settings.gradle para determinar que proyectos tomarán parte del build.
Configuration: durante esta fase se ejecutan los ficheros build.gradle de los proyectos.
Execution: se ejecuta la tarea encomendada y todas las sub-tareas de las cuales depende (definidas con dependsOn) .
Veamos el build lifecycle en un single project build:
settings.gradle
println 'Esto se ejecuta durante la fase INITIALIZATION'
build.gradle
println 'Esto se ejecuta durante la fase CONFIGURATION'
tasks.register('tarea1') {
doFirst {
println 'Esto se ejecuta en primer lugar en la fase EXECUTION de la tarea :tarea1'
}
println 'Esto se ejecuta en la fase CONFIGURATION de la tarea :tarea1'
}
tasks.register('tarea2') {
doLast {
println 'Esto se ejecuta en último lugar en la fase EXECUTION de la tarea :tarea2'
}
println 'Esto se ejecuta en la fase CONFIGURATION de la tarea :tarea2'
doFirst {
println 'Esto se ejecuta en primer lugar en la fase EXECUTION de la tarea :tarea2'
}
}
tasks.register('tareaXYZ') {
doLast {
println 'Esto se ejecuta en último lugar en la fase EXECUTION de la tarea :tareaXYZ'
}
dependsOn tarea1
println 'Esto se ejecuta en la fase CONFIGURATION de la tarea :tareaXYZ'
dependsOn tarea2
doFirst {
println 'Esto se ejecuta en primer lugar en la fase EXECUTION de la tarea :tareaXYZ'
}
}
Haz las actividades propuestas en este proyecto: https://github.com/gerardfp/MyGDXGradleTask
Directorios y ficheros que usa Gradle
https://docs.gradle.org/current/userguide/directory_layout.html
Gradle user home directory
├── caches
├── daemon
├── init.d
│ └── my-setup.gradle
├── jdks
│ ├── ⋮
│ └── jdk-14.0.2+12
├── wrapper
│ └── dists
│ ├── ⋮
│ ├── gradle-4.8-bin
│ ├── gradle-4.9-all
│ └── gradle-4.9-bin
└── gradle.properties
Directorio de cache global (para todo lo que no sea específico de un proyecto)
Registro y logs del Gradle Daemon
Scripts de inicialización globales
JDKs descargados por el toolchain support
Distribuciones descargadas por el Gradle Wrapper
Configuración global de Gradle
Project root directory
├── .gradle
│ ├── 4.8
│ ├── 4.9
│ └── ⋮
├── build
├── gradle
│ └── wrapper
├── gradle.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
├── subproject-one
| └── build.gradle
├── subproject-two
| └── build.gradle
└── ⋮
Build Scripts
https://docs.gradle.org/current/userguide/tutorial_using_tasks.html
Los Build Scripts son código:
Bucles:
4.times {
println 'Esto se imprime 4 veces'
}
Variables:
String someString = 'mY_nAmE'
println "Original: $someString"
println "Upper case: ${someString.toUpperCase()}"
Métodos:
fileList(".").each { file ->
println "Se ha encontrado $file.name"
}
File[] fileList(String dir) {
file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()
}
Plugins
Los plugins añaden Tareas y Extensiones al DSL. El siguiente plugin añade la Tarea tareaDeMiPrimerPlugin y la extensión miPrimeraExtension
abstract class MiPrimeraExtension {
void miPrimerMetodo(String variable) {
println "miPrimerMetodo ha recibido $variable"
}
}
class MiPrimerPlugin implements Plugin<Project> {
void apply(Project project) {
println 'Fase CONFIGURATION de MiPrimerPlugin'
project.tasks.register('tareaDeMiPrimerPlugin') {
doLast {
println 'Fase EXECUTION de :tareaDeMiPrimerPlugin'
}
}
project.extensions.create("miPrimeraExtension", MiPrimeraExtension.class)
}
}
apply plugin: MiPrimerPlugin
miPrimeraExtension {
miPrimerMetodo "HOolaa"
}
El plugin 'java'
El plugin Java añade la capacidad de compilar, testear y empaquetar proyectos Java.
Para utilizar el Java plugin, se debe incorporar al build script:
build.gradle
plugins {
id 'java'
}
Tareas:
- build: agrega las tareas 'check' y 'assemble'.
- check: realiza tareas de verificación, como lanzar los tests.
- assemble: ensambla el proyecto, generando por ejemplo un fichero JAR.
- clean: elimina el directorio build del proyecto.
- javadoc: genera la documentación de la API usando Javadoc.
Layout del proyecto
El Java plugin asume por defecto que el proyecto está organizado en los directorios siguientes. No tienen porqué existir estos directorios,
el plugin compilará los que encuentre. Estos directorios se pueden configurar.
- src/main/java: el código fuente de producción del proyecto
- src/main/resources: recursos de producción, como ficheros de propiedades o datos XML
- src/test/java: el código fuente de testeo del proyecto
- src/test/resources: recursos de testeo
Dependencias
El Java plugin añade una serie de configuraciones de dependencias
- implementation
- runtimeOnly
- compileOnly
- testImplementation
- testRuntimeOnly
- testCompileOnly
Ensamblado de un JAR
La tarea jar es la encargada de ensamblar un proyecto en un fichero JAR. Un fichero JAR es un fichero comprimido en formato ZIP que contiene
los ficheros .class del proyecto y los recursos auxiliares que puediese tener (imágenes, ficheros de datos, configuraciones, ...).
Si el fichero JAR contiene una aplicación para ser ejecutada, se debe especificar el entry point en el fichero /META-INF/MANIFEST.MF dentro del propio JAR.
Para ello, se debe incluir el siguiente attributo:
/META-INF/MANIFEST.MF
Main-Class: classname
El classname debe ser el nombre de la classe precedido por el package:
Por ejemplo, si la clase principal se encuentra en la siguiente ruta:
.
└── src
└── main
└── java
└── my
└── superpackage
└── ClasePrincipal.java
El entrypoint del manifest debería ser así:
Main-Class: my.superpackage.ClasePrincipal
Esta clase debe tener el método psvm : public static void main(String[] args).
La tarea JAR del plugin Java se puede configurar para que incluya el atributo Main-Class en el fichero Manifest del JAR:
build.gradle
jar {
manifest {
attributes "Main-Class": "className"
}
}
Uber JAR (o Fat Jar)
Un Uber JAR es un JAR con las dependencias incluidas. No solo contiene las clases del proyecto sino que además incluye los JAR
dependientes.
La tarea JAR también se puede configurar para que incluya todos los JAR de los cuales depende el proyecto en el JAR ensamblado:
build.gradle
jar {
manifest {
attributes "Main-Class": "className"
}
from {
configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
}