Ciclo di vita del build Maven in Java

Un ciclo di vita è l'idea centrale di Maven: costruire un progetto non è un insieme arbitrario di compiti, ma una sequenza ordinata di fasi ben note. Quando digiti mvn package, non stai nominando un'azione singola — stai chiedendo a Maven di eseguire ogni fase fino a package inclusa, in ordine. Capire questa sequenza, e come gli obiettivi dei plugin vi si collegano, è la differenza tra copiare comandi a caso e sapere davvero cosa fa il tuo build.

Tre cicli di vita, e quello che usi di più

Maven include tre cicli di vita integrati. Sono indipendenti — invocare una fase di uno non attiva gli altri.

Il ciclo di vita default è dove avviene il lavoro vero. Quel mvn clean install che vedi ovunque è semplicemente due cicli di vita in un unico comando: la fase clean del ciclo clean, poi la fase install del ciclo default.

Le fasi del ciclo di vita default

Il ciclo di vita default ha 23 fasi, ma sette portano il peso di quasi ogni build. Vengono sempre eseguite in questo ordine:

La regola che governa tutto: eseguire una fase esegue quella fase e tutte le fasi precedenti. Quindi mvn package esegue silenziosamente validate, compile e test prima. Non c'è modo di "saltare avanti" — puoi solo fermarti prima.

mvn validate     # just the sanity checks
mvn compile      # validate -> compile
mvn test         # validate -> compile -> test
mvn package      # ... -> test -> package (produces target/app-1.0.jar)
mvn install      # ... -> package -> verify -> install (now in ~/.m2)
mvn deploy       # the full pipeline, ending with an upload

Le fasi sono vuote finché i plugin non vi associano obiettivi

Una fase è solo un nome e una posizione nella sequenza — non esegue alcun lavoro da sola. Il lavoro è svolto dagli obiettivi dei plugin che sono associati alle fasi. Un obiettivo si scrive come plugin:goal, ad es. compiler:compile. Per un progetto il cui <packaging> è jar, Maven fornisce un insieme sensato di associazioni predefinite:

Puoi aggiungere le tue associazioni in pom.xml. Qui il plugin exec è collegato alla fase verify in modo che venga eseguito automaticamente verso la fine del build:

<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>exec-maven-plugin</artifactId>
      <version>3.1.0</version>
      <executions>
        <execution>
          <id>smoke-test</id>
          <phase>verify</phase>
          <goals><goal>java</goal></goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Puoi anche invocare un obiettivo direttamente, al di fuori di qualsiasi fase — mvn compiler:compile esegue solo quell'obiettivo, saltando completamente il ciclo di vita. Questo è occasionalmente utile, ma nel quotidiano chiami le fasi e lasci che le associazioni si attivino.

Un esempio pratico: simulare il ciclo di vita

Maven non è installato su questo runner, quindi modelliamo il ciclo di vita in Java puro per rendere concreti i suoi meccanismi. Il programma elenca le fasi default, registra il plugin:goal associato a ciascuna, poi "esegue" mvn install — eseguendo ogni fase da validate fino a install, e dimostrando che deploy e clean non vengono inclusi.

Cosa ricavare dall'esecuzione:

• L'output parte da validate e si ferma a install — sei fasi per un solo comando. È la regola cumulativa in azione: mvn install è un'abbreviazione per eseguire l'intero prefisso della sequenza fino a install, non solo la singola fase nominata.
• Ogni fase eseguita ha stampato il plugin:goal ad essa associato (compile -> compiler:compile, package -> jar:jar, e così via). Le fasi sono slot; gli obiettivi sono ciò che effettivamente compila, testa e impacchetta. validate ha stampato (no goal bound), mostrando che una fase può essere eseguita senza fare nulla.
• deploy skipped : true conferma che le fasi successive a quella richiesta non vengono mai eseguite. Per pubblicare su un repository remoto devi chiedere esplicitamente mvn deploy; un semplice install rimane deliberatamente locale.
• clean ran : false dimostra che clean appartiene a un ciclo di vita separato. Invocare install non elimina target/, ed è esattamente per questo che mvn clean install li specifica entrambi — una fase da ciascun ciclo di vita.
• Le fasi sono state eseguite nel seguente ordine fisso: validate, compile, test, package, verify, install, e il programma si è concluso con BUILD SUCCESS. L'ordine non è negoziabile; la promessa di convention-over-configuration di Maven si basa su questa sequenza garantita e ripetibile.

Comandi comuni nella pratica

Un manciata di invocazioni copre quasi tutto il lavoro quotidiano:

mvn clean              # delete target/
mvn test               # build and run unit tests
mvn package -DskipTests  # build the JAR without running tests
mvn clean install      # fresh build, install to local ~/.m2
mvn clean verify       # CI's favourite: build + unit + integration checks

-DskipTests compila i test ma non li esegue; -Dmaven.test.skip=true salta anche la compilazione. Usa il primo quando i test sono lenti ma devono comunque compilare, il secondo solo quando vuoi davvero escluderli del tutto.

Dove andare dopo

• Nuovo allo strumento? Inizia con l'introduzione a Maven, poi leggi come il POM dichiara plugin e associazioni.
• Le fasi come compile e package hanno successo solo dopo che le librerie del progetto sono state risolte — vedi gestione delle dipendenze.
• Preferisci un modello a grafo di attività rispetto a una sequenza di fasi fissa? Confronta con l'introduzione a Gradle.

Esercitati