Maven vs Gradle: diferencias, velocidad y cuál elegir en Java
Comparamos Maven y Gradle con el mismo proyecto Java: archivos de configuración, tiempos de build medidos, caché incremental y cuándo elegir cada uno.
En resumen: Maven usa un
pom.xmldeclarativo y un ciclo de vida fijo: predecible y fácil de leer para cualquiera. Gradle usa un script (Kotlin o Groovy) programable, con builds incrementales y caché: más rápido en proyectos grandes y más flexible, pero también más fácil de complicar. Con el mismo proyecto medimos 3,7 s en Maven y 0,6 s en Gradle en la segunda ejecución sin cambios. Para aprender y para la mayoría de proyectos Spring Boot, Maven sigue siendo la opción más común; Gradle compensa en monorepos grandes y en Android.
Vídeo explicativo
El mismo proyecto con las dos herramientas
Un proyecto mínimo: una clase Calculadora y un test de JUnit. Con Maven:
<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>calculadora</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>6.1.3</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.5.6</version>
</plugin>
</plugins>
</build>
</project>
Con Gradle (Kotlin DSL), build.gradle.kts más un settings.gradle.kts con rootProject.name = "calculadora":
plugins {
java
}
group = "com.example"
version = "1.0.0"
java {
toolchain {
languageVersion = JavaLanguageVersion.of(21)
}
}
repositories {
mavenCentral()
}
dependencies {
testImplementation("org.junit.jupiter:junit-jupiter:6.1.3")
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}
tasks.test {
useJUnitPlatform()
}
La estructura de carpetas (src/main/java, src/test/java) y el repositorio de dependencias (Maven Central) son los mismos: Gradle adoptó las convenciones de Maven.
Lo que medimos
Construimos ese proyecto con Maven 3.10.1 y Gradle 9.9.1, con las dependencias ya descargadas:
| Escenario | mvn package | gradle build |
|---|---|---|
Desde limpio (clean antes) | 9,4 s | 4,9 s |
| Segunda ejecución sin cambios | 3,7 s | 0,6 s |
La diferencia en la segunda ejecución viene del build incremental: Gradle detecta que nada cambió y marca las tareas como UP-TO-DATE sin ejecutarlas:
> Task :compileJava UP-TO-DATE
> Task :classes UP-TO-DATE
> Task :jar UP-TO-DATE
> Task :assemble UP-TO-DATE
> Task :compileTestJava UP-TO-DATE
Maven vuelve a recorrer su ciclo de vida y a ejecutar los tests. Tómalo como orientación: en un proyecto de una clase lo que domina es el arranque de cada herramienta, y Gradle mantiene un proceso en segundo plano (daemon) ya arrancado. En proyectos grandes con muchos módulos la ventaja de Gradle suele crecer, sobre todo con su caché de build.
Comparación
| Maven | Gradle | |
|---|---|---|
| Configuración | XML declarativo | Script Kotlin o Groovy |
| Modelo | Ciclo de vida fijo (compile, test, package, install) | Grafo de tareas configurable |
| Build incremental y caché | Limitado | Sí, de serie |
| Curva de aprendizaje | Baja | Media; alta si se abusa del scripting |
| Previsibilidad | Muy alta: todos los proyectos se parecen | Depende de cómo se escriba el script |
| Lógica de build propia | Plugins | Código en el propio build |
| Uso típico | Backend empresarial, Spring Boot | Android, monorepos grandes, proyectos Kotlin |
| Soporte en Spring Initializr | Sí | Sí (Groovy y Kotlin) |
Comandos equivalentes
| Acción | Maven | Gradle |
|---|---|---|
| Compilar | mvn compile | gradle compileJava |
| Ejecutar tests | mvn test | gradle test |
| Empaquetar | mvn package | gradle build |
| Limpiar | mvn clean | gradle clean |
| Ver dependencias | mvn dependency:tree | gradle dependencies |
| Arrancar Spring Boot | mvn spring-boot:run | gradle bootRun |
Usa siempre el wrapper del proyecto (./mvnw o ./gradlew): fija la versión de la herramienta para todo el equipo y para el CI.
Cuál elegir
- Elige Maven si estás aprendiendo, si tu equipo o empresa ya lo usa o si valoras que cualquier desarrollador entienda el build a la primera.
- Elige Gradle si tienes muchos módulos y los tiempos de build importan, si trabajas con Android o Kotlin, o si necesitas lógica de build a medida.
Cambiar de uno a otro más adelante es viable; lo que importa es no llenar el build de lógica que nadie entiende.
Preguntas frecuentes
¿Gradle es siempre más rápido?
En builds repetidos e incrementales, normalmente sí. En una primera compilación desde cero la diferencia es menor, y depende de los plugins y de la configuración.
¿Puedo usar dependencias de Maven Central en Gradle?
Sí, Gradle las descarga del mismo repositorio con mavenCentral().
¿Kotlin DSL o Groovy en Gradle?
Kotlin DSL (.kts): el IDE autocompleta y detecta errores al escribir. Es la opción por defecto en los proyectos nuevos de Gradle.
¿Qué es Maven en profundidad?
Lo explicamos en el vídeo ¿Qué es MAVEN? y en artículos prácticos como instalar un JAR local en Maven.
Sigue aprendiendo
En el curso de Spring Boot desde cero creas y gestionas proyectos con Maven desde el primer día. Para empezar un proyecto, tienes crear una aplicación de Spring Boot.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.