Introducción a Java Maven

Maven es la herramienta estándar de automatización de compilación y gestión de dependencias para Java. Convierte un proyecto en una descripción declarativa — qué es, de qué depende, cómo se construye — y luego ejecuta la compilación por usted. En lugar de gestionar a mano archivos JAR y opciones de javac, usted declara sus necesidades en un único archivo y Maven descarga las dependencias, compila, prueba y empaqueta su código a través de un ciclo de vida predecible y repetible.

El POM: un proyecto como datos

Todo proyecto Maven se describe mediante un pom.xml (Project Object Model). Identifica el proyecto con tres coordenadas — groupId, artifactId y version (juntas, el «GAV») — y enumera las bibliotecas que necesita. El mismo esquema de coordenadas nombra su proyecto y cada dependencia, que es como Maven localiza los artefactos en un repositorio.

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>shop-app</artifactId>
  <version>1.0.0</version>
  <packaging>jar</packaging>

  <properties>
    <maven.compiler.release>21</maven.compiler.release>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>6.1.0</version>
    </dependency>
  </dependencies>
</project>

El elemento <packaging> le dice a Maven qué producir (jar, war, pom). El bloque <properties> contiene valores reutilizables — aquí, la versión de Java a la que apunta el compilador.

Las dependencias y el classpath transitivo

Usted enumera solo sus dependencias directas. Maven lee el POM propio de cada dependencia e incorpora todo lo que ellas necesitan — las dependencias transitivas — construyendo el classpath completo automáticamente. Declarar spring-web también incorpora spring-core sin que usted lo nombre.

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.0</version>
</dependency>

Cada dependencia tiene un ámbito (scope) que controla cuándo está en el classpath. El valor predeterminado, compile, la hace disponible en todas partes; test la limita al código de prueba; provided significa que el entorno de ejecución la suministra.

Ámbito	En classpath de compilación	En classpath de prueba	Empaquetada	Uso típico
`compile` (predeterminado)	Sí	Sí	Sí	Bibliotecas normales
`provided`	Sí	Sí	No	API Servlet, suministrada en ejecución
`runtime`	No	Sí	Sí	Controladores JDBC
`test`	No	Sí	No	JUnit, Mockito

El ciclo de vida de la compilación

Las compilaciones de Maven se ejecutan a través de una secuencia fija de fases. Las fases clave del ciclo de vida predeterminado son validate, compile, test, package, verify, install y deploy. Ejecutar una fase ejecuta todas las fases anteriores a ella — mvn package primero valida, compila y prueba, y luego empaqueta. Nunca llama a las fases fuera de orden.

mvn compile          # compilar las fuentes principales
mvn test             # compilar + ejecutar pruebas unitarias
mvn package          # compilar + probar + construir el JAR/WAR
mvn install          # empaquetar + copiar el artefacto en su repositorio local
mvn clean package    # eliminar target/ primero, luego construir de cero

Cada fase está ligada a uno o más goals suministrados por plugins (por ejemplo, compiler:compile está ligado a la fase compile). En los plugins vive el trabajo real; el ciclo de vida solo lo ordena.

Los repositorios

Maven obtiene los artefactos de repositorios. Cuando usted compila, busca primero en su repositorio local (~/.m2/repository), una caché en su máquina. Ante una falta, descarga desde un repositorio remoto — por defecto Maven Central — y almacena una copia localmente para que la siguiente compilación sea rápida y sin conexión. Los equipos suelen añadir un repositorio privado para las bibliotecas internas.

pom.xml del proyecto  →  repo local (~/.m2)  →  repo remoto (Maven Central)
                         (¿acierto de caché?)    (descargar + cachear)

Un ejemplo ejecutable

El ejecutor de código no tiene Maven en su classpath, así que el programa siguiente modela la mecánica fundamental de Maven con simple código del JDK: almacena un POM diminuto como un map, resuelve el cierre transitivo de dependencias (eliminando duplicados de artefactos compartidos) y recorre el ciclo de vida de la compilación, deteniéndose en la fase solicitada. Las formas aquí — coordenadas GAV, resolución transitiva, fases ordenadas — son exactamente lo que hace el Maven real.

java— editable, runs on the server

import java.util.*;

public class Main {
    // A coordinate triple, exactly like Maven's groupId:artifactId:version.
    record Gav(String groupId, String artifactId, String version) {
        @Override public String toString() {
            return groupId + ":" + artifactId + ":" + version;
        }
        String jar() { return artifactId + "-" + version + ".jar"; }
    }

// The project model: each artifact mapped to the dependencies it declares.
    static final Map<String, List<Gav>> pom = new LinkedHashMap<>();

static void declare(Gav a, Gav... deps) { pom.put(a.toString(), List.of(deps)); }

// Build the transitive closure the way Maven resolves a classpath.
    static void resolve(Gav a, Set<String> seen, List<Gav> out) {
        for (Gav d : pom.getOrDefault(a.toString(), List.of())) {
            if (seen.add(d.toString())) {   // de-dupe: each JAR appears once
                out.add(d);
                resolve(d, seen, out);      // then pull in its own dependencies
            }
        }
    }

public static void main(String[] args) {
        Gav app     = new Gav("com.example", "shop-app", "1.0.0");
        Gav web     = new Gav("org.springframework", "spring-web", "6.1.0");
        Gav core    = new Gav("org.springframework", "spring-core", "6.1.0");
        Gav jackson = new Gav("com.fasterxml.jackson.core", "jackson-databind", "2.17.0");
        Gav annot   = new Gav("com.fasterxml.jackson.core", "jackson-annotations", "2.17.0");

declare(app, web, jackson);   // our project's direct dependencies
        declare(web, core);           // spring-web transitively needs spring-core
        declare(jackson, annot);      // jackson-databind needs jackson-annotations
        declare(core);
        declare(annot);

System.out.println("Project coordinates: " + app);
        System.out.println("Direct dependencies:");
        for (Gav d : pom.get(app.toString())) System.out.println("  - " + d);

List<Gav> classpath = new ArrayList<>();
        resolve(app, new HashSet<>(), classpath);
        System.out.println("Resolved classpath has " + classpath.size() + " JARs:");
        for (Gav g : classpath) System.out.println("  - " + g.jar());

List<String> phases = List.of("validate", "compile", "test", "package", "install");
        String goal = "package";
        System.out.println("Executing: mvn " + goal);
        for (String p : phases) {
            System.out.println("  phase " + p + " -> OK");
            if (p.equals(goal)) break;   // stop once the requested phase is reached
        }
        System.out.println("BUILD SUCCESS");
    }
}

Qué llevarse de la ejecución:

El proyecto y cada dependencia se nombran con el mismo triplete GAV, por eso Project coordinates: com.example:shop-app:1.0.0 se lee exactamente como una línea de dependencia.
Solo se declaran dos dependencias, pero el classpath resuelto tiene cuatro JARs — spring-core y jackson-annotations se incorporaron de forma transitiva, exactamente como hace Maven.
El conjunto seen garantiza que cada artefacto aparezca una sola vez; esta es la deduplicación de Maven que impide que una biblioteca compartida acabe dos veces en el classpath.
Executing: mvn package ejecuta validate, compile y test antes de package y luego se detiene — ejecutar una fase siempre ejecuta cada fase anterior en orden.
La compilación se detiene en package y nunca llega a install, reflejando cómo el goal solicitado acota hasta dónde avanza el ciclo de vida.

Práctica

En Maven, ¿qué ocurre cuando se ejecuta 'mvn package'?

Maven ejecuta cada fase anterior del ciclo de vida (validate, compile, test) y luego empaqueta el artefacto
Maven ejecuta solo la fase package y omite la compilación y las pruebas
Maven despliega el artefacto en un repositorio remoto
Maven descarga el JDK antes de compilar