Artículo

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.xml declarativo 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:

Escenariomvn packagegradle build
Desde limpio (clean antes)9,4 s4,9 s
Segunda ejecución sin cambios3,7 s0,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

MavenGradle
ConfiguraciónXML declarativoScript Kotlin o Groovy
ModeloCiclo de vida fijo (compile, test, package, install)Grafo de tareas configurable
Build incremental y cachéLimitadoSí, de serie
Curva de aprendizajeBajaMedia; alta si se abusa del scripting
PrevisibilidadMuy alta: todos los proyectos se parecenDepende de cómo se escriba el script
Lógica de build propiaPluginsCódigo en el propio build
Uso típicoBackend empresarial, Spring BootAndroid, monorepos grandes, proyectos Kotlin
Soporte en Spring InitializrSíSí (Groovy y Kotlin)

Comandos equivalentes

AcciónMavenGradle
Compilarmvn compilegradle compileJava
Ejecutar testsmvn testgradle test
Empaquetarmvn packagegradle build
Limpiarmvn cleangradle clean
Ver dependenciasmvn dependency:treegradle dependencies
Arrancar Spring Bootmvn spring-boot:rungradle 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.

maven gradle java herramientas de build 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.

Compartir artículo