Ciclo de vida e fases

O Maven organiza a construção de um projeto num ciclo de vida (lifecycle): uma sequência ordenada de fases. Quando pede uma fase, o Maven executa todas as fases anteriores pela ordem.

É o princípio mais importante a reter:

Pedir uma fase executa automaticamente todas as que a precedem. mvn package lança portanto também validate, compile e test.

O Maven possui na realidade três ciclos de vida:

# Executar uma fase = executar tudo até ela
mvn package      # lança validate -> compile -> test -> package

🔧 Mini-exercício — Quais fases se executam quando lança mvn package? Liste-as pela ordem.

O ciclo de vida default tem muitas fases; eis as mais usadas no dia a dia:

mvn validate    # verificações de base
mvn compile     # + compilação
mvn test        # + testes unitários
mvn package     # + criação do artefacto
mvn verify      # + testes de integração
mvn install     # + cópia para ~/.m2
mvn deploy      # + publicação remota

Quanto mais se avança na lista, mais o Maven faz. mvn install é o « canivete suíço » do desenvolvimento local: constrói tudo e torna o artefacto disponível para os seus outros projetos na mesma máquina.

A fase compile transforma o seu código Java (src/main/java) em bytecode (.class) colocado em target/classes. É o plugin Compiler que se encarrega disso, usando o javac do JDK.

A versão de Java usada é definida pelas propriedades vistas na lição 02:

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

# Compilar o código principal
mvn compile

# Compilar também o código de teste
mvn test-compile

🔧 Mini-exercício — Em que pasta o bytecode .class do código principal é depositado após mvn compile?

Resultado em target/:

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

Se a compilação falhar (BUILD FAILURE), o Maven para imediatamente: as fases seguintes (test, package) não se executam. Corrigem-se sempre primeiro os erros de compilação.

A fase test executa os testes unitários situados em src/test/java. É o plugin Surefire que os lança, geralmente com o framework JUnit.

Um teste JUnit típico:

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

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

# Executar todos os testes
mvn test

# Executar uma só classe de teste
mvn test -Dtest=CalculTest

# Construir SALTANDO os testes (a evitar, salvo caso preciso)
mvn package -DskipTests

🔧 Mini-exercício — Escreva o comando Maven que empacota o projeto sem lançar os testes.

mvn package -DskipTests

⚠️ Se um só teste falhar, o build inteiro falha (BUILD FAILURE) e o package não é produzido. É intencional: não se entrega um artefacto cujos testes não passam. Saltar os testes com -DskipTests deve permanecer excecional.

A fase package junta o código compilado num artefacto entregável, depositado em target/. O tipo de artefacto depende da etiqueta <packaging> do pom.xml.

<!-- Escolha do tipo de artefacto -->
<packaging>jar</packaging>

# Produzir o artefacto
mvn package

# Localizar o resultado
ls target/

Resultado:

target/
├── classes/
├── mon-app-1.0.0-SNAPSHOT.jar   <-- o artefacto entregável
└── ...

O nome do artefacto segue o padrão artifactId-version.packaging. Exemplo: mon-app-1.0.0-SNAPSHOT.jar. É este ficheiro que se distribui ou implanta.

Após package, três operações completam o ciclo de vida.

A combinação clean install é uma das mais frequentes: garante um build totalmente limpo.

# Recomeçar do zero e construir tudo até à instalação local
mvn clean install

# Construir e publicar no repositório remoto da equipa
mvn clean deploy

mvn clean install é o reflexo a adotar quando « já não funciona sem razão »: o clean elimina ficheiros compilados eventualmente obsoletos em target/.

🔧 Mini-exercício — Escreva o comando que recomeça de um target/ limpo e depois instala o artefacto no repositório local ~/.m2.

mvn clean install

Question 1

O que acontece quando lança mvn package?

a) Só a fase package se executa

b) O Maven executa também todas as fases anteriores (validate, compile, test)

c) O Maven publica o artefacto num repositório remoto

d) O Maven elimina a pasta target/

Question 2

Que plugin Maven executa os testes unitários?

a) Compiler

b) Surefire

c) Shade

d) Jar

Question 3

O que faz a fase install?

a) Instala o Maven na máquina

b) Copia o artefacto para o repositório local ~/.m2

c) Publica no Maven Central

d) Elimina target/

Question 4

Que etiqueta determina se o projeto produz um .jar ou um .war?

a) <scope>

b) <version>

c) <packaging>

d) <artifactId>

Question 5

O que acontece durante mvn package se um teste unitário falhar?

a) O artefacto é mesmo assim produzido

b) O build falha (BUILD FAILURE) e o artefacto não é produzido

c) O Maven ignora o teste

d) O Maven passa diretamente a deploy

Instrução

Num projeto Maven, percorra o ciclo de vida passo a passo: limpe, compile, teste, empacote e depois instale localmente. Observe em cada etapa o que o Maven produz em target/.

Correção — Sequência de comandos esperada

# 1. Recomeçar do zero: elimina target/
mvn clean

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

# 3. Testar: o Surefire executa os testes JUnit
mvn test

# 4. Empacotar: produz o .jar em target/
mvn package
ls target/*.jar          # mon-app-1.0.0-SNAPSHOT.jar

# 5. Instalar no repositório local ~/.m2
mvn install

# Variante condensada mais frequente:
mvn clean install

Resultado esperado:

[INFO] --- compiler:compile --- (target/classes criado)
[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

Observe a ordem das linhas [INFO]: compile, depois test, depois jar, depois install. É a prova visível de que o Maven encadeia automaticamente as fases pela ordem do ciclo de vida.

Pontos a reter

1. O ciclo de vida é uma sequência ordenada de fases; pedir uma fase executa todas as anteriores.
2. Fases-chave: validate → compile → test → package → verify → install → deploy.
3. compile (plugin Compiler) produz o bytecode em target/classes.
4. test (plugin Surefire + JUnit) executa os testes; uma falha interrompe o build.
5. package cria o .jar/.war; install copia-o para ~/.m2; clean esvazia target/.

A continuação

Domina agora o Maven: estrutura, pom.xml, dependências e ciclo de vida. O módulo 04 abordará a contentorização com Docker, onde empacotará estes artefactos Maven em imagens portáteis.