Configuração de Construção Maven POM Maven

Ciclo de Construção Maven

O ciclo de vida de construção do Maven define o processo de construção e lançamento de um projeto.

Um ciclo de vida de construção (build) típico do Maven é composto pela sequência das seguintes fases:

Fase	Tratamento	descrição
Verificação validate	Verificar o projeto	Verificar se o projeto está correto e se todas as informações necessárias estão disponíveis
Compilação compile	Executar a compilação	A compilação do código-fonte é concluída neste estágio
Teste Test	Teste	Executar testes usando o framework de teste de unidade apropriado (por exemplo, JUnit).
Empacotamento package	Empacotamento	Criar JAR/Se o pacote WAR for mencionado no pom.xml
Verificação verify	Verificação	Verificar os resultados dos testes integrados para garantir que a qualidade atenda aos padrões
Instalação install	Instalação	Instalar o projeto empacotado no repositório local para uso por outros projetos
Deploy deploy	Deploy	Copiar o pacote final do projeto para o repositório remoto para compartilhar com outros desenvolvedores e projetos

Para completar o ciclo de vida default, essas fases (incluindo outras fases de ciclo de vida não listadas acima) serão executadas em ordem.

O Maven tem os seguintes três ciclos de vida padrão:

limpeza: Tratamento da limpeza do projeto
default (ou build): Tratamento do deploy do projeto
site: Tratamento da criação de documentos do site do projeto

As fases de construção são compostas por objetivos de plugin

Um objetivo de plugin representa uma tarefa específica (mais refinada do que a fase de construção), o que ajuda na construção e gestão do projeto. Esses objetivos podem ser ligados a várias fases ou não ligados. Objetivos não ligados a nenhuma fase de construção podem ser executados diretamente fora do ciclo de vida de construção. A ordem de execução desses objetivos depende da ordem de chamada dos objetivos e das fases de construção.

Por exemplo, considere o seguinte comando:

Clean e pakage são fases de construção, dependency:copy-As dependências são o objetivo

mvn clean dependency:copy-Dependências package

A fase de limpeza aqui será executada primeiro, seguida pela dependency:copy-As dependências serão executadas, e finalmente, a fase do pacote será executada.

Ciclo de Vida de Limpeza

ao executarmos mvn pós-ao executar o comando limpeza, o Maven chama o ciclo de vida de limpeza, que contém as seguintes fases:

pre-limpeza: executa algumas tarefas que precisam ser concluídas antes da limpeza
limpeza: remove todos os arquivos gerados na última construção
post-limpeza: executa algumas tarefas que precisam ser concluídas imediatamente após a limpeza

O comando mvn clean contém a limpeza acima, em um ciclo de vida, ao executar uma fase, todas as fases anteriores serão executadas, isso é, se executarmos mvn clean, serão executadas as seguintes duas fases do ciclo de vida:

pre-se executarmos mvn clean

limpeza, limpeza-se executarmos mvn pós

pre-limpeza, limpeza, pós-limpeza

Podemos modificar o comportamento dessa parte operacional definindo um objetivo em qualquer fase do ciclo de vida de limpeza acima.

No exemplo a seguir, usaremos o maven-antrun-o objetivo plugin:run é adicionado ao pré-limpeza, limpeza e pós-na fase de limpeza. Dessa forma, podemos exibir informações de texto em todas as fases do ciclo de vida de limpeza.

Já criamos um arquivo pom.xml no diretório 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>
<versão>1.0</versão>
<build>
<plugins>
　　　<plugin>
　　　<groupId>org.apache.maven.plugins</groupId>
　　　<artifactId>maven-antrun-plugin</artifactId>
　　　<versão>1.1</versão>
　　　<executions>
　　　　　　<execution>
　　　　　　　　　<id>id.pré-limpeza</id>
　　　　　　　　　<fase>pré-limpeza</fase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>pré-fase de limpeza</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.limpeza</id>
　　　　　　　　　<phase>limpeza</fase>
　　　　　　　　　<goals>
　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>fase de limpeza</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.pós-limpeza</id>
　　　　　　　　　<fase>pós-limpeza</fase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>pós-fase de limpeza</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　</executions>
　　　</plugin>
</plugins>
</build>
</project>

Agora abra o console de comando, navegue até o diretório onde o pom.xml está localizado e execute o comando mvn a seguir.

C:\MVN\project>mvn pós-limpeza

O Maven começará a processar e exibir todas as fases do ciclo de vida de limpeza.

[INFO] Pesquisa de projetos...
[INFO]　------------------------------------------------------------------
[INFO] Construção de无名　-　com.companyname.projectgroup:project:jar:1.0
[INFO]      tarefa-segmento: [pós-limpeza]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-limpeza}]
[INFO] Executando tarefas
　　　　　[echo] pré-fase de limpeza
[INFO] Tarefas Executadas
[INFO] [limpeza:limpeza {execution: default}]-limpeza}]
[INFO] [antrun:run {execution: id.limpeza}]
[INFO] Executando tarefas
　　　　　[echo] fase de limpeza
[INFO] Tarefas Executadas
[INFO] [antrun:run {execution: id.pós}]-limpeza}]
[INFO] Executando tarefas
　　　　　[echo] pós-fase de limpeza
[INFO] Tarefas Executadas
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUÇÃO BEM SUCESSO
[INFO]　------------------------------------------------------------------
[INFO] Tempo Total: <　1　segundo
[INFO] Finalizado em: Sáb Jul 07　13:38:59　IST　2012
[INFO] Memória Final:　4M/44M
[INFO]　------------------------------------------------------------------

Você pode tentar modificar o comando mvn clean para exibir o pre-limpeza e limpeza, enquanto no post-A fase de limpeza não executa nenhuma operação.

Ciclo de Vida (Construção) Padrão

Este é o ciclo de vida principal do Maven, usado para construir aplicações, incluindo os seguintes 23 fase(s):

fase de ciclo de vida	descrição
validate (validar)	Verifique se o projeto está correto e se todas as informações necessárias podem completar o processo de construção do projeto.
initialize (inicializar)	Inicialize o estado de construção, por exemplo, configure valores de propriedade.
generate-sources (gerar código-fonte)	Gere qualquer código-fonte incluído no estágio de compilação.
process-sources (tratar código-fonte)	Trate o código-fonte, por exemplo, filtre qualquer valor.
generate-resources (gerar arquivos de recursos)	Gere os arquivos de recursos que serão incluídos no pacote do projeto.
process-resources (tratar arquivos de recursos)	Copie e trate os recursos para o diretório de destino, preparando-o para a fase de empacotamento.
compile (compilar)	Compile o código-fonte do projeto.
process-classes (tratar arquivos de classes)	Trate os arquivos gerados pela compilação, por exemplo, otimize a melhoria do bytecode dos arquivos Java class.
generate-test-sources (gerar código-fonte de teste)	Gere qualquer código-fonte de teste incluído no estágio de compilação.
process-test-sources (tratar código-fonte de teste)	Trate o código-fonte de teste, por exemplo, filtre qualquer valor.
generate-test-resources (gerar arquivos de recursos de teste)	Crie arquivos de recursos para o teste.
process-test-resources (tratar arquivos de recursos de teste)	Copie e trate os recursos para o diretório de destino.
test-compile (compilar código-fonte de teste)	Compile o código-fonte de teste para o diretório de destino do teste.
process-test-classes (tratar arquivos de classes de teste)	Trate os arquivos gerados pela compilação do código de teste.
test (teste)	Execute testes usando o framework de teste de unidade apropriado (Juint é um deles).
prepare-package (preparação para empacotamento)	Execute qualquer operação necessária para preparar o empacotamento antes do empacotamento real.
package (empacotamento)	Empacote o código compilado em um formato distribuível, como arquivos JAR, WAR ou EAR.
pre-integration-test (antes do teste de integração)	Execute as ações necessárias antes de executar o teste de integração. Por exemplo, configure o ambiente necessário.
integration-test (teste de integração)	Trate e deploy o projeto para um ambiente que possa executar o teste de integração.
post-integration-test (após teste de integração)	Execute as ações necessárias após a conclusão do teste de integração. Por exemplo, limpe o ambiente de teste de integração.
verify (verificar)	Execute qualquer verificação para verificar se o pacote do projeto é válido e atinge os padrões de qualidade.
install (instalação)	Instale o pacote do projeto no repositório local, para que o pacote possa ser usado como dependência de outros projetos locais.
deploy (despacho)	Copie o pacote final para o repositório remoto para compartilhar com outros desenvolvedores e projetos.

Existem alguns conceitos importantes relacionados ao ciclo de vida do Maven que precisam ser explicados:

ao chamar uma fase pelo comando Maven, por exemplo mvn compile, apenas as fases antes dessa e incluídas nela serão executadas.

diferentes objetivos do Maven dependem do tipo de empacotamento (JAR / WAR / EAR), ligado a diferentes fases do ciclo de vida do Maven.

No exemplo a seguir, usaremos o maven-antrun-plugin:executar o objetivo adicionado a uma fase da vida do Build. Dessa forma, podemos exibir as informações textuais do ciclo de vida.

Já atualizamos o arquivo pom.xml na pasta 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>
<versão>1.0</versão>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<versão>1.1</versão>
<executions>
　　　<execution>
　　　　　　<id>id.validação</id>
　　　　　　<fase>validate</fase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>fase de validação</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.compilação</id>
　　　　　　<fase>compile</fase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>fase de compilação</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.test</id>
　　　　　　<fase>test</fase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>fase de teste</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　　　　<id>id.empacotamento</id>
　　　　　　　　　<fase>package</fase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>fase de empacotamento</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.distribuição</id>
　　　　　　<fase>deploy</fase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　<tasks>
　　　　　　　　　<echo>fase de distribuição</echo>
　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Agora abra o console de comando, navegue até o diretório onde o pom.xml está localizado e execute o seguinte comando mvn.

C:\MVN\project>mvn compile

O Maven começará a processar e exibir todas as etapas do ciclo de vida da construção até a fase de compilação.

[INFO] Pesquisa de projetos...
[INFO]　------------------------------------------------------------------
[INFO] Construção de无名　-　com.companyname.projectgroup:project:jar:1.0
[INFO]      tarefa-segmento: [compile]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:executar {execução: id.validate}]
[INFO] Executando tarefas
　　　　　[echo] fase de validação
[INFO] Tarefas Executadas
[INFO] [recursos:recursos {execução: default-recursos}]
[AVISO] Usando codificação da plataforma (Cp1252　de fato) para copiar recursos filtrados,
i.e. a construção depende da plataforma!
[INFO] pular diretório de recursos inexistente C:\MVN\project\src\main\resources
[INFO] [compilador:compile {execução: default-compile}]
[INFO] Nada para compilar　-　todas as classes estão atualizadas
[INFO] [antrun:run {execution: id.compile}]
[INFO] Executando tarefas
　　　　　[echo] fase de compilação
[INFO] Tarefas Executadas
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUÇÃO BEM SUCESSO
[INFO]　------------------------------------------------------------------
[INFO] Tempo Total:　2　segundos
[INFO] Finalizado em: Sáb Jul 07　20:18:25　IST　2012
[INFO] Memória Final:　7M/64M
[INFO]　------------------------------------------------------------------

Chamada de linha de comando

No ambiente de desenvolvimento, use o comando a seguir para construir e instalar o projeto no repositório local

mvn install

Este comando, antes de executar a fase install, executa as fases do ciclo de vida default (validar, compilar, empacotar, etc.) em ordem, precisamos chamar a última fase, como aqui é install.

No ambiente de construção, use a chamada a seguir para construir e deployar o projeto para o repositório compartilhado de forma limpa

mvn clean deploy

Esta linha de comando também pode ser usada em situações de múltiplos módulos, ou seja, projetos que contêm múltiplos subprojetos, o Maven executará o comando clean em cada subprojeto, antes de executar o comando deploy.

Ciclo de vida do Site

O plug-in Maven Site geralmente é usado para criar novos documentos de relatório, deploy de site, etc.

pre-site: executar algumas tarefas que precisam ser concluídas antes da geração dos documentos do site
site: gerar os documentos do site do projeto
post-site: executar algumas tarefas que precisam ser concluídas após a geração dos documentos do site, e preparar para o deploy
site-deploy: deploy os documentos do site gerados para um servidor específico

Aqui, o que é frequentemente usado é a fase site e site-fase deploy, usada para gerar e publicar o site Maven, que é uma funcionalidade bastante poderosa do Maven, muito preferida pelo Manager, geração automática de documentos e estatísticas, muito bonito. No exemplo a seguir, usaremos o maven-antrun-O objetivo plugin:run foi adicionado a todas as fases do ciclo de vida do Site. Dessa forma, podemos exibir todas as informações de texto do ciclo de vida.