Ciclo de vida y fases

Maven organiza la construcción de un proyecto en un ciclo de vida (lifecycle): una sucesión ordenada de fases. Cuando pides una fase, Maven ejecuta todas las fases anteriores en orden.

Este es el principio más importante que hay que retener:

Pedir una fase ejecuta automáticamente todas las que la preceden. mvn package lanza por tanto también validate, compile y test.

Maven tiene en realidad tres ciclos de vida:

# Ejecutar una fase = ejecutar todo hasta ella
mvn package      # lanza validate -> compile -> test -> package

🔧 Mini-ejercicio — ¿Qué fases se ejecutan cuando lanzas mvn package? Lístalas en orden.

El ciclo de vida default incluye muchas fases; estas son las más usadas en el día a día:

mvn validate    # verificaciones de base
mvn compile     # + compilación
mvn test        # + pruebas unitarias
mvn package     # + creación del artefacto
mvn verify      # + pruebas de integración
mvn install     # + copia en ~/.m2
mvn deploy      # + publicación remota

Cuanto más avanzas en la lista, más hace Maven. mvn install es la «navaja suiza» del desarrollo local: construye todo y deja el artefacto disponible para tus otros proyectos en la misma máquina.

La fase compile transforma tu código Java (src/main/java) en bytecode (.class) colocado en target/classes. Se encarga el plugin Compiler, usando el javac del JDK.

La versión de Java usada se define con las propiedades vistas en la lección 02:

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

# Compilar el código principal
mvn compile

# Compilar también el código de prueba
mvn test-compile

🔧 Mini-ejercicio — ¿En qué carpeta se deposita el bytecode .class del código principal después de mvn compile?

Resultado en target/:

target/
└── classes/
    └── com/exemple/App.class   <-- bytecode compilado

Si la compilación falla (BUILD FAILURE), Maven se detiene de inmediato: las fases siguientes (test, package) no se ejecutan. Siempre se corrigen primero los errores de compilación.

La fase test ejecuta las pruebas unitarias situadas en src/test/java. Las lanza el plugin Surefire, por lo general con el framework JUnit.

Una prueba JUnit típica:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class CalculTest {
    @Test
    void additionDeDeuxNombres() {
        assertEquals(4, 2 + 2);
    }
}

# Ejecutar todas las pruebas
mvn test

# Ejecutar una sola clase de prueba
mvn test -Dtest=CalculTest

# Construir SALTANDO las pruebas (a evitar, salvo caso preciso)
mvn package -DskipTests

🔧 Mini-ejercicio — Escribe el comando Maven que empaqueta el proyecto sin lanzar las pruebas.

mvn package -DskipTests

⚠️ Si una sola prueba falla, todo el build falla (BUILD FAILURE) y no se produce el package. Es intencionado: no se entrega un artefacto cuyas pruebas no pasan. Saltar las pruebas con -DskipTests debe seguir siendo excepcional.

La fase package ensambla el código compilado en un artefacto entregable, depositado en target/. El tipo de artefacto depende de la etiqueta <packaging> del pom.xml.

<!-- Elección del tipo de artefacto -->
<packaging>jar</packaging>

# Producir el artefacto
mvn package

# Localizar el resultado
ls target/

Resultado:

target/
├── classes/
├── mon-app-1.0.0-SNAPSHOT.jar   <-- el artefacto entregable
└── ...

El nombre del artefacto sigue el patrón artifactId-version.packaging. Ejemplo: mon-app-1.0.0-SNAPSHOT.jar. Ese es el archivo que distribuyes o despliegas.

Después de package, tres operaciones completan el ciclo de vida.

La combinación clean install es una de las más habituales: garantiza un build totalmente limpio.

# Partir de cero y construir todo hasta la instalación local
mvn clean install

# Construir y publicar en el repositorio remoto del equipo
mvn clean deploy

mvn clean install es el reflejo a adoptar cuando «ya no funciona sin motivo»: el clean elimina posibles archivos compilados obsoletos en target/.

🔧 Mini-ejercicio — Escribe el comando que parte de un target/ limpio y luego instala el artefacto en el repositorio local ~/.m2.

mvn clean install

Question 1

¿Qué ocurre cuando lanzas mvn package?

a) Solo se ejecuta la fase package

b) Maven ejecuta también todas las fases anteriores (validate, compile, test)

c) Maven publica el artefacto en un repositorio remoto

d) Maven elimina la carpeta target/

Question 2

¿Qué plugin Maven ejecuta las pruebas unitarias?

a) Compiler

b) Surefire

c) Shade

d) Jar

Question 3

¿Qué hace la fase install?

a) Instala Maven en la máquina

b) Copia el artefacto en el repositorio local ~/.m2

c) Publica en Maven Central

d) Elimina target/

Question 4

¿Qué etiqueta determina si el proyecto produce un .jar o un .war?

a) <scope>

b) <version>

c) <packaging>

d) <artifactId>

Question 5

¿Qué ocurre durante mvn package si una prueba unitaria falla?

a) El artefacto se produce de todos modos

b) El build falla (BUILD FAILURE) y no se produce el artefacto

c) Maven ignora la prueba

d) Maven pasa directamente a deploy

Corrigé

1. b — Pedir package ejecuta también validate, compile y test.
2. b — Surefire ejecuta las pruebas unitarias con JUnit.
3. b — install copia el artefacto en ~/.m2.
4. c — <packaging> decide entre .jar y .war.
5. b — Un test fallido provoca BUILD FAILURE y no se produce el artefacto.

Consigna

Sobre un proyecto Maven, recorre el ciclo de vida paso a paso: limpia, compila, prueba, empaqueta y luego instala en local. Observa en cada etapa lo que Maven produce en target/.

Corrección — Secuencia de comandos esperada

# 1. Partir de cero: elimina target/
mvn clean

# 2. Compilar: produce target/classes
mvn compile
ls target/classes        # bytecode .class presente

# 3. Probar: Surefire ejecuta las pruebas JUnit
mvn test

# 4. Empaquetar: produce el .jar en target/
mvn package
ls target/*.jar          # mon-app-1.0.0-SNAPSHOT.jar

# 5. Instalar en el repositorio local ~/.m2
mvn install

# Variante condensada más habitual:
mvn clean install

Resultado esperado:

[INFO] --- compiler:compile --- (target/classes creado)
[INFO] --- surefire:test --- Tests run: 1, Failures: 0, Errors: 0
[INFO] --- jar:jar --- Building jar: target/mon-app-1.0.0-SNAPSHOT.jar
[INFO] --- install:install --- Installing ... to ~/.m2/repository/...
[INFO] BUILD SUCCESS

Observa el orden de las líneas [INFO]: compile, luego test, luego jar, luego install. Es la prueba visible de que Maven encadena automáticamente las fases en el orden del ciclo de vida.

Puntos a recordar

1. El ciclo de vida es una sucesión ordenada de fases; pedir una fase ejecuta todas las anteriores.
2. Fases clave: validate → compile → test → package → verify → install → deploy.
3. compile (plugin Compiler) produce el bytecode en target/classes.
4. test (plugin Surefire + JUnit) ejecuta las pruebas; un fallo detiene el build.
5. package crea el .jar/.war; install lo copia en ~/.m2; clean vacía target/.

A continuación

Ya dominas Maven: estructura, pom.xml, dependencias y ciclo de vida. El módulo 04 abordará la contenedorización con Docker, donde empaquetarás estos artefactos Maven en imágenes portátiles.