Gradle

Contexto y relaciones

¿Qué es Gradle?

  • Herramienta de automatización de builds y gestión de dependencias
  • Orientada a flexibilidad, rendimiento y configuración programática
  • Muy utilizada en:
    • Proyectos Java/JVM
    • Android
    • Builds complejos y multiproyecto
  • Diseñada para integrarse fácilmente en pipelines de CICD

Gradle vs Maven

  • vs maven
  • Gradle vs Maven Definitions and main Differences-
  • Diferencias clave:
    • Gradle:
      • DSL programable (Groovy o Kotlin)
      • Builds incrementales y cacheados
      • Mejor rendimiento en proyectos grandes
    • Maven:
      • Configuración declarativa (XML)
      • Convención sobre configuración
      • Menor flexibilidad, mayor simplicidad inicial

DSL y configuración

  • DSL principal:
    • Groovy (más común históricamente)
    • Kotlin DSL (tipado fuerte, mejor autocompletado)
  • Ventajas del DSL:
    • Lógica condicional
    • Reutilización de código
    • Configuración dinámica según entorno

Gestión de dependencias

  • Resolución avanzada de dependencias:
    • Versiones dinámicas
    • Exclusiones
    • Conflictos y prioridades
  • Repositorios:
    • Maven Central
    • Google
    • Repositorios privados
  • Soporte para:
    • JARs
    • Librerías internas
    • Dependencias transitivas

Optimización de compilación y tests

  • optimizar compilacion y correr tests
  • Características clave:
    • Incremental builds
    • Build cache (local y remoto)
    • Parallel execution
  • Beneficios:
    • Menores tiempos de build
    • Feedback rápido en testing
    • Escalabilidad en equipos grandes

Variables de tiempo y entorno

  • time variables
  • Uso de:
    • Variables de entorno
    • Propiedades del sistema
    • Archivos gradle.properties
  • Casos comunes:
    • Configuración por entorno (dev, staging, prod)
    • Versionado automático
    • Flags de compilación

Multiproyectos

  • multiproyectos
  • Estructura:
    • Proyecto raíz
    • Subproyectos
  • Ventajas:
    • Reutilización de módulos
    • Builds coherentes
    • Separación de responsabilidades
  • Casos típicos:
    • Backend modular
    • Librerías compartidas
    • Monorepos

Plugins de Gradle

Creación de librerías Java

  • crear librerias en java
  • Artefactos comunes:
    • JAR
  • Publicación:
    • Repositorios Maven
    • Servicios externos
  • Plataforma útil:
    • [JitPack Publish JVM and Android libraries](https://jitpack.io/)
  • Casos de uso:
    • Librerías internas
    • SDKs
    • Componentes reutilizables

Gradle en Android

  • compilar android
  • Sistema de build oficial de Android
  • Integración con:
    • Android Studio
    • Flavors y build types
    • ProGuard / R8
  • Ventajas:
    • Builds rápidos
    • Configuración por variante
    • Automatización avanzada

Documentación oficial

Recursos en video

Gradle — Conceptos avanzados y temas complementarios

Ciclo de vida del build

  • Fases del build:
    • Initialization
    • Configuration
    • Execution
  • Importancia:
    • Evitar lógica costosa en configuración
    • Mejorar rendimiento y predictibilidad
  • Conceptos clave:
    • Configuration avoidance
    • Lazy evaluation

Tareas (Tasks) en profundidad

  • Task:
    • Unidad básica de trabajo en Gradle
  • Características:
    • Inputs y outputs declarados
    • Up-to-date checks
    • Incremental execution
  • Tipos:
    • Tareas estándar
    • Tareas personalizadas
    • Tareas cacheables

Configuration Cache

  • Mecanismo para reutilizar la fase de configuración
  • Beneficios:
    • Builds significativamente más rápidos
  • Requisitos:
    • Builds deterministas
    • Evitar acceso directo a estado mutable en configuración

Gradle Wrapper

  • Uso de gradlew
  • Ventajas:
    • Versiones de Gradle consistentes en equipos y CI
    • No requiere instalación global
  • Archivos clave:
    • gradle-wrapper.properties

Archivos clave del proyecto

  • build.gradle / build.gradle.kts
  • settings.gradle / settings.gradle.kts
  • gradle.properties
  • Responsabilidades:
    • settings:
      • Nombre del proyecto
      • Inclusión de subproyectos
    • build:
      • Plugins
      • Dependencias
      • Tareas

Version Catalogs

  • Centralización de versiones
  • Archivo:
    • libs.versions.toml
  • Ventajas:
    • Evita duplicación
    • Mejor mantenimiento
    • Consistencia entre módulos
  • Uso común en multiproyectos

Dependency Locking

  • Bloqueo explícito de versiones
  • Objetivo:
    • Builds reproducibles
  • Casos de uso:
    • Evitar cambios inesperados
    • Estabilidad en CI
  • Integración con control de versiones

Publicación de artefactos

  • Publishing:
    • Maven Publish Plugin
  • Soporte para:
    • Librerías
    • Plugins
  • Destinos:
    • Repositorios privados
    • Repositorios públicos
  • Metadatos:
    • Versionado
    • POM generado automáticamente

Composite Builds

  • Builds que se consumen entre sí sin publicar
  • Ventajas:
    • Desarrollo local de librerías
    • Feedback inmediato
  • Alternativa a:
    • Publicación temporal en repositorios

Testing avanzado

  • Integración con:
    • JUnit
    • TestNG
    • Spock
  • Tipos de tests:
    • Unitarios
    • Integración
    • Funcionales
  • Features:
    • Test filtering
    • Paralelización
    • Reports personalizables

Tooling API

  • API de Gradle para herramientas externas
  • Casos de uso:
    • IDEs
    • Herramientas de análisis
    • Automatización externa
  • Permite:
    • Ejecutar builds
    • Inspeccionar modelos del proyecto

Seguridad en Gradle

  • Verificación de dependencias:
    • Checksums
    • Signatures
  • Protección de credenciales:
    • Variables de entorno
    • Gradle properties
  • Buenas prácticas:
    • No hardcodear secretos
    • Usar vaults o CI secrets

Inicialización de proyectos

  • gradle init
  • Generación de:
    • Estructura base
    • Tipos de proyecto
  • Útil para:
    • Nuevos proyectos
    • Estandarización

Rendimiento y diagnóstico

  • Flags útiles:
    • --scan
    • --profile
  • Build scans:
    • Análisis detallado de rendimiento
    • Identificación de cuellos de botella

Compatibilidad y ecosistema

  • Integración con:
    • CICD
    • Docker
    • Cloud builds
  • Soporte multiplataforma:
    • JVM
    • Android
    • Native (limitado)

Cuándo elegir Gradle

  • Proyectos grandes o complejos
  • Builds altamente personalizados
  • Necesidad de rendimiento y escalabilidad
  • Entornos con múltiples módulos y librerías compartidas

Gradle — Guía práctica con ejemplos de código y uso

Inicializar un proyecto

Crear proyecto base

gradle init

`

  • Permite elegir:

    • Tipo de proyecto (application, library)
    • DSL (Groovy / Kotlin)
    • Lenguaje (Java, Kotlin, etc.)

  • Genera estructura estándar y Wrapper

Estructura básica de un proyecto

  • Archivos principales:

    • settings.gradle
    • build.gradle
    • gradle.properties

Configuración mínima Java

build.gradle

plugins {
	id 'java'
}

group = 'com.example'
version = '1.0.0'

repositories {
	mavenCentral()
}

dependencies {
	testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
}

test {
	useJUnitPlatform()
}

Gestión de dependencias

Añadir dependencias

dependencies {
	implementation 'com.google.guava:guava:33.0.0-jre'
	runtimeOnly 'ch.qos.logback:logback-classic:1.5.3'
}

Excluir dependencias transitivas

implementation('org.springframework.boot:spring-boot-starter-web') {
	exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
}

Uso de Version Catalogs

libs.versions.toml

[versions]
junit = "5.10.0"

[libraries]
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }

build.gradle

dependencies {
	testImplementation libs.junit.jupiter
}

Definición de tareas personalizadas

Task simple

tasks.register('hello') {
	doLast {
		println 'Hola desde Gradle'
	}
}

Ejecutar

./gradlew hello

Tareas con inputs y outputs

Task incremental

tasks.register('copyFiles', Copy) {
	from 'src/resources'
	into "$buildDir/resources"
}

Variables de entorno y propiedades

gradle.properties

appVersion=1.2.3

build.gradle

version = project.findProperty("appVersion") ?: "0.0.1"

Variables de entorno

def env = System.getenv("ENV") ?: "dev"
println "Entorno actual: $env"

Proyecto multiproyecto

settings.gradle

rootProject.name = 'demo-multiproject'
include 'core', 'api'

build.gradle (root)

subprojects {
	apply plugin: 'java'

	repositories {
		mavenCentral()
	}
}

Dependencias entre módulos

api/build.gradle

dependencies {
	implementation project(':core')
}

Testing

Ejecutar tests

./gradlew test

Filtrar tests

./gradlew test --tests "*ServiceTest"

Build cache y paralelización

gradle.properties

org.gradle.parallel=true
org.gradle.caching=true

Uso del Wrapper

Ejecutar build

./gradlew build

Actualizar versión de Gradle

./gradlew wrapper --gradle-version 8.7

Crear un JAR ejecutable

build.gradle

jar {
	manifest {
		attributes(
			'Main-Class': 'com.example.Main'
		)
	}
}

Fat JAR con Shadow plugin

build.gradle

plugins {
	id 'java'
	id 'com.github.johnrengelman.shadow' version '8.1.1'
}

shadowJar {
	archiveClassifier.set('all')
}

Ejecutar

./gradlew shadowJar

Publicar una librería

build.gradle

plugins {
	id 'java-library'
	id 'maven-publish'
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			from components.java
		}
	}
	repositories {
		maven {
			url = uri("https://maven.example.com/releases")
		}
	}
}

Uso con JitPack

  • Requisitos:
    • Repositorio público en GitHub
    • Tag de versión
  • Dependencia desde otro proyecto:
repositories {
	maven { url 'https://jitpack.io' }
}

dependencies {
	implementation 'com.github.usuario:repositorio:1.0.0'
}

Gradle en CI

Ejemplo básico

./gradlew clean build

  • Buenas prácticas:

    • Usar Wrapper
    • Cachear .gradle y build
    • Usar --no-daemon en CI

Diagnóstico y análisis

Build scan

./gradlew build --scan

Perfil de rendimiento

./gradlew build --profile

Comandos útiles

./gradlew tasks
./gradlew dependencies
./gradlew build
./gradlew clean

Estado de Gradle en 2025 y herramientas del ecosistema

1. Estado general del Gradle Build Tool

  • Gradle sigue siendo uno de los sistemas de automatización de builds más usados para proyectos JVM/Android y multiplataforma.
  • Ofrece potente gestión de dependencias, builds incrementales y tareas personalizadas, con adopción continua en la industria.
  • Más información: Gradle Wikipedia

2. Develocity — Observabilidad avanzada y AI para builds

  • El plugin de Develocity para Gradle (com.gradle.develocity) está reemplazando al antiguo plugin de Build Scan y es el estándar moderno para analizar y optimizar builds.
  • Versión principal y mejoras recientes:
    • La línea de versiones 4.x del plugin Develocity añade soporte para Build Scan, test distribution resiliente y APIs mejoradas.
    • La versión Develocity 2025.4 incluye agrupamiento de fallos con AI y servidores MCP para integraciones avanzadas y análisis de builds.
  • Artículos/documentación clave:

3. Build Scan (Build Insights)

  • Aunque el plugin com.gradle.build-scan está deprecado, la funcionalidad de Build Scan continúa viva y evolucionando vía Develocity.
  • Guía oficial para usar Build Scan (opción --scan): Gradle Build Scans

4. Ecosistema de plugins indexado por deps.dev

  • El portal deps.dev ahora indexa el ecosistema completo de plugins de Gradle, con más de 15 000 paquetes y ~270 000 versiones.
  • Esto facilita:
    • Explorar versiones compatibles
    • Auditar vulnerabilidades
    • Buscar alternativas a plugins existentes
  • Más información: Deps.dev Gradle Plugins

5. Proyectos comunitarios en 2025

  • Varias iniciativas de Google Summer of Code 2025 relacionadas con Gradle incluyen mejoras en:
    • Plugins de publicación a Maven Central con nuevas APIs.
    • Mejoras en Configuration Cache y reducción de lock contention.
    • Gradle Convention Plugin para Jenkins Plugins.
  • Referencias: Gradle Community Newsletter 2025

6. Declarative Gradle — DSL experimental

  • Declarative Gradle (DCL) es un proyecto experimental de Gradle para un lenguaje de configuración declarativo más simple y “developer‑first”.
  • Está en Early Access Preview (EAP), con mejoras continuas en soporte para tipos, listas y archivos.
  • No está listo para producción, pero ya tiene demos y documentación pública.
  • Más información: Declarative Gradle Blog
  • Documentación experimental: Declarative Gradle GitHub

7. Releases principales de Gradle en 2025

  • En 2025 se han publicado Gradle 9.1.0 y 9.2.0 con:
    • Soporte para Java 25
    • Mejoras en CLI y visualización
    • Diagnósticos de conflicto de versiones
    • Mejoras de compatibilidad con Configuration Cache
    • Soporte oficial del Gradle Docker image mantenido por el equipo de Gradle
  • Más información: Gradle Releases

8. Integración con IDEs y productividad

  • El plugin Develocity IntelliJ Plugin proporciona visualización de tiempos de tareas y recursos directamente en el IDE.
  • Declarative Gradle también avanza con soporte en IDEs como IntelliJ IDEA y Android Studio para destacar archivos .dcl
  • Más información: Declarative Gradle IDE Support

9. Tendencias de productividad y best practices

  • Newsletters oficiales y blogs de Gradle en 2025 enfatizan:
    • Mejores prácticas de configuración
    • Uso efectivo de Configuration Cache
    • Integración de métricas y Build & Test Failure Trends para mejorar confiabilidad
  • Más información: Gradle Enterprise Trends & Insights

10. Visión y perspectivas del ecosistema

Tendencias claras en 2025:

  • Consolidación de herramientas de observabilidad y AI (Develocity)
  • Ecosistema de plugins más visible y auditable (deps.dev)
  • Exploración de Lenguajes declarativos para definir builds (Declarative Gradle)
  • Mejores experiencias de IDE y productividad en toolchains de build
  • Gradle siguiendo fuerte adopción en proyectos grandes y complejos con pipelines CI/CD