File di configurazione di costruzione Maven POM di Maven

Ciclo di vita di costruzione di Maven

Maven 构建生命周期定义了一个项目构建跟发布的过程。

一个典型的 Maven 构建(build)生命周期是由以下几个阶段的序列组成的：

阶段	处理	Descrizione
验证　validate	验证项目	验证项目是否正确且所有必须信息是可用的
编译　compile	执行编译	源代码编译在此阶段完成
测试　Test	测试	使用适当的单元测试框架（例如JUnit）运行测试。
包装　package	打包	创建JAR/WAR包如在 pom.xml 中定义提及的包
检查　verify	检查	对集成测试的结果进行检查，以保证质量达标
安装 install	安装	安装打包的项目到本地仓库，以供其他项目使用
部署 deploy	部署	拷贝最终的工程包到远程仓库中，以共享给其他开发人员和工程

为了完成 default 生命周期，这些阶段（包括其他未在上面罗列的生命周期阶段）将被按顺序地执行。

Maven 有以下三个标准的生命周期：

clean：项目清理的处理
default(或 build)：项目部署的处理
site：项目站点文档创建的处理

构建阶段由插件目标构成

一个插件目标代表一个特定的任务（比构建阶段更为精细），这有助于项目的构建和管理。这些目标可能被绑定到多个阶段或者无绑定。不绑定到任何构建阶段的目标可以在构建生命周期之外通过直接调用执行。这些目标的执行顺序取决于调用目标和构建阶段的顺序。

例如，考虑下面的命令：

clean 和 pakage 是构建阶段，dependency:copy-dependencies 是目标

mvn　clean　dependency:copy-dependencies　package

这里的 clean 阶段将会被首先执行，然后 dependency:copy-dependencies 目标会被执行，最终 package 阶段被执行。

Clean 生命周期

当我们执行 mvn post-clean 命令时，Maven 调用 clean 生命周期，它包含以下阶段：

pre-clean：执行一些需要在clean之前完成的工作
clean：移除所有上一次构建生成的文件
post-clean：执行一些需要在clean之后立刻完成的工作

clean in mvn clean è quella sopra menzionata. In un ciclo di vita, quando si esegue una fase, tutte le fasi precedenti verranno eseguite, quindi se si esegue mvn clean verranno eseguite le seguenti due fasi del ciclo di vita:

pre-clean, clean

Se eseguiamo mvn post-clean, verranno eseguite le seguenti tre fasi del ciclo di vita:

pre-clean, clean, post-clean

Possiamo modificare il comportamento di questa sezione definendo un goal in qualsiasi fase del ciclo di vita clean menzionato sopra.

Nell'esempio seguente, aggiungeremo il goal maven-antrun-plugin:run alle fasi pre-clean, clean e post-clean. In questo modo possiamo mostrare messaggi di testo nelle diverse fasi del ciclo di vita clean.

Abbiamo creato un file pom.xml nella directory C:\MVN\project.

<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
　　　http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
　　　<plugin>
　　　<groupId>org.apache.maven.plugins</groupId>
　　　<artifactId>maven-antrun-plugin</artifactId>
　　　<version>1.1</version>
　　　<executions>
　　　　　　<execution>
　　　　　　　　　<id>id.pre-clean</id>
　　　　　　　　　<phase>pre-clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>fase di pre-pulizia</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.clean</id>
　　　　　　　　　<phase>clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>fase di pulizia</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.post-clean</id>
　　　　　　　　　<phase>post-clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>fase di post-pulizia</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　</executions>
　　　</plugin>
</plugins>
</build>
</project>

Ora apri la console dei comandi, vai alla directory del file pom.xml e esegui il comando mvn seguente.

C:\MVN\project>mvn post-clean

Maven inizierà a elaborare e mostrerà tutte le fasi del ciclo di vita clean.

[INFO] Ricerca per progetti...
[INFO]　------------------------------------------------------------------
[INFO] Costruzione di Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO]      segmento-lavoro: [post-clean]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-clean}]
[INFO]　Eseguendo i compiti
　　　　　[echo] fase di pre-pulizia
[INFO]　Eseguiti i compiti
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO]　Eseguendo i compiti
　　　　　[echo] fase di pulizia
[INFO]　Eseguiti i compiti
[INFO] [antrun:run {execution: id.post-clean}]
[INFO]　Eseguendo i compiti
　　　　　[echo] fase post-clean
[INFO]　Eseguiti i compiti
[INFO]　------------------------------------------------------------------
[INFO]　COSTRUIRE CON SUCCESSO
[INFO]　------------------------------------------------------------------
[INFO] Tempo totale: < 1 secondo
[INFO] Completato il 7 lug 2012 13:38:59 IST
[INFO] Memoria finale: 4M/44M
[INFO]　------------------------------------------------------------------

Puoi provare a modificare il comando mvn clean per visualizzare pre-clean e clean, senza eseguire alcuna operazione nella fase post-clean.

Ciclo di vita predefinito (Build)

Questo è il ciclo di vita principale di Maven, utilizzato per costruire applicazioni, comprese le seguenti 23 fasi:

Fasi del ciclo di vita	Descrizione
validate (verifica)	Verifica che il progetto sia corretto e che tutte le informazioni necessarie possano completare il processo di costruzione del progetto.
initialize (inizializza)	Inizializza lo stato di costruzione, ad esempio, impostando i valori delle proprietà.
generate-sources (genera codice sorgente)	Genera qualsiasi codice sorgente incluso nella fase di compilazione.
process-sources (gestisci il codice sorgente)	Gestisci il codice sorgente, ad esempio, filtrando valori casuali.
generate-resources (genera file delle risorse)	Genera i file delle risorse che verranno inclusi nel pacchetto del progetto.
process-resources (gestisci i file delle risorse)	Copia e gestisci le risorse nel directory di destinazione, preparandosi al meglio per la fase di packaging.
compile (compila)	Compila il codice sorgente del progetto.
process-classes (gestisci i file delle classi)	Gestisci i file generati dalla compilazione, ad esempio, migliorando l'ottimizzazione del bytecode dei file Java class.
generate-test-sources (genera codice di test)	Genera qualsiasi codice di test incluso nella fase di compilazione.
process-test-sources (gestisci il codice di test)	Gestisci il codice di test, ad esempio, filtrando valori casuali.
generate-test-resources (genera file di risorse di test)	Crea file di risorse per il test.
process-test-resources (gestisci i file delle risorse di test)	Copia e gestisci le risorse di test nel directory di destinazione.
test-compile (compila il codice di test)	Compila il codice di test nel directory di destinazione dei test.
process-test-classes (gestisci i file delle classi di test)	Gestisci i file generati dalla compilazione del codice di test.
test (test)	Esegui i test utilizzando un framework di test unitario (Juint è uno di essi).
prepare-package (preparazione del pacchetto)	Eseguire qualsiasi operazione necessaria per preparare il pacchetto prima del pacchettaggio effettivo.
package (pacchettizzazione)	Pacchettare il codice compilato in un formato distribuibile come file JAR, WAR o EAR.
pre-integration-test (prima del test di integrazione)	Eseguire azioni necessarie prima dell'esecuzione dei test di integrazione. Ad esempio, costruire l'ambiente necessario.
integration-test (test di integrazione)	Elaborare e distribuire il progetto in un ambiente di test di integrazione che può essere eseguito.
post-integration-test (dopo il test di integrazione)	Eseguire azioni necessarie dopo l'esecuzione dei test di integrazione. Ad esempio, pulire l'ambiente di test di integrazione.
verify (verifica)	Eseguire qualsiasi controllo per verificare che il pacchetto del progetto sia valido e raggiunga gli standard di qualità.
install (install)	Installare il pacchetto del progetto nel deposito locale in modo che il pacchetto del progetto possa essere utilizzato come dipendenza per altri progetti locali.
deploy (deploy)	Copiare il pacchetto del progetto finale nel deposito remoto per condividerlo con altri sviluppatori e progetti.

Ci sono alcune importanti concetti relativi alla vita del Maven che devono essere spiegati:

Quando una fase viene chiamata tramite il comando Maven, ad esempio mvn compile, verranno eseguite tutte le fasi precedenti e inclusa la fase stessa.

Diversi obiettivi Maven saranno vincolati a diverse fasi della vita del Maven in base al tipo di imballaggio (JAR / WAR / EAR).

Nella seguente esempio, aggiungeremo l'obiettivo maven-antrun-plugin:run alla fase di parte della vita del Build. In questo modo possiamo visualizzare le informazioni testuali della vita.

Abbiamo aggiornato il file pom.xml nella directory C:\MVN\project.

<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
　　http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
　　　<execution>
　　　　　　<id>id.validate</id>
　　　　　　<phase>validate</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>validate phase</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.compile</id>
　　　　　　<phase>compile</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>compile phase</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.test</id>
　　　　　　<phase>test</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>test phase</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　　　　<id>id.package</id>
　　　　　　　　　<phase>package</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>package phase</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.deploy</id>
　　　　　　<phase>deploy</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　<tasks>
　　　　　　　　　<echo>deploy phase</echo>
　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Ora apri la console dei comandi, vai alla directory in cui si trova pom.xml e esegui il seguente comando mvn.

C:\MVN\project>mvn compile

Maven inizierà a elaborare e mostrare tutte le fasi del ciclo di vita di costruzione fino alla fase di compilazione.

[INFO] Ricerca per progetti...
[INFO]　------------------------------------------------------------------
[INFO] Costruzione di Unnamed - com.companyname.projectgroup:project:jar:1.0
task-segment: [compile]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:run {execution: id.validate}]
[INFO]　Eseguendo i compiti
　　　　　[echo] fase di validazione
[INFO]　Eseguiti i compiti
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Utilizzo della codifica della piattaforma (Cp1252 effettivamente) per copiare le risorse filtrate,
cioè, la costruzione è dipendente dalla piattaforma!
Salta la directory delle risorse non esistente C:\MVN\project\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Non c'è nulla da compilare - tutte le classi sono aggiornate
[INFO] [antrun:run {execution: id.compile}]
[INFO]　Eseguendo i compiti
　　　　　[echo] fase di compilazione
[INFO]　Eseguiti i compiti
[INFO]　------------------------------------------------------------------
[INFO]　COSTRUIRE CON SUCCESSO
[INFO]　------------------------------------------------------------------
[INFO] Tempo totale: 2 secondi
[INFO] Completato il 7 luglio 2012 alle 20:18:25 IST
[INFO] Memoria finale: 7M/64M
[INFO]　------------------------------------------------------------------

Chiamata da riga di comando

Nel contesto di sviluppo, utilizzare i seguenti comandi per costruire e installare il progetto nel deposito locale.

mvn install

Questo comando esegue in ordine i livelli del ciclo di vita predefinito (validate, compile, package, ecc.) prima di eseguire la fase install, dobbiamo chiamare l'ultima fase, come qui install.

Nel contesto dell'ambiente di costruzione, utilizzare la seguente chiamata per costruire e distribuire il progetto in modo pulito nel deposito condiviso.

mvn clean deploy

Questa riga di comando può anche essere utilizzata in situazioni a più moduli, ovvero progetti che contengono più sotto-progetti, Maven esegue il comando clean per ogni sotto-progetto e poi esegue il comando deploy.

Ciclo di vita Site

Il plugin Maven Site generalmente viene utilizzato per creare nuovi documenti di report, distribuire siti, ecc.

pre-site:执行一些需要在生成站点文档之前完成的工作
site:生成项目的站点文档
post-site:执行一些需要在生成站点文档之后完成的工作，并为部署做准备
site-deploy:部署生成的站点文档到特定的服务器上

Di solito si utilizzano le fasi site e site-deploy per generare e pubblicare il sito Maven, una funzione molto potente di Maven, che piace molto al Manager, con generazione automatica di documentazione e statistiche, molto gradevole. Nell'esempio seguente, aggiungeremo l'obiettivo maven-antrun-plugin:run a tutte le fasi del ciclo di vita di Site. In questo modo, possiamo visualizzare tutte le informazioni di testo del ciclo di vita.