Maven - construir ciclo de vida

O que é Build Lifecycle?

Um Build Lifecycle é uma sequência bem definida de fases, que definem a ordem em que os objetivos devem ser executados. Aqui, a fase representa um estágio do ciclo de vida. Por exemplo, um típicoMaven Build Lifecycle consiste na seguinte sequência de fases.

Fase Alças Descrição
prepare-resources cópia de recursos A cópia de recursos pode ser personalizada nesta fase.
validar Validando a informação Valida se o projeto está correto e se todas as informações necessárias estão disponíveis.
compilar compilação A compilação do código-fonte é feita nesta fase.
Teste Testando Testa o código-fonte compilado adequado para testar a estrutura.
pacote embalagem Esta fase cria o pacote JAR / WAR conforme mencionado no pacote em POM.xml.
instalar instalação Esta fase instala o pacote no repositório maven local / remoto.
Implantar Implantando Copia o pacote final para o repositório remoto.

Sempre têm pre e post fases para registrar goals, que deve ser executado antes ou depois de uma determinada fase.

Quando o Maven começa a construir um projeto, ele passa por uma sequência definida de fases e executa metas, que são registradas em cada fase.

O Maven tem os três ciclos de vida padrão a seguir -

  • clean
  • padrão (ou build)
  • site

UMA goalrepresenta uma tarefa específica que contribui para a construção e gestão de um projeto. Ele pode estar limitado a zero ou mais fases de construção. Um objetivo não vinculado a nenhuma fase de construção pode ser executado fora do ciclo de vida de construção por invocação direta.

A ordem de execução depende da ordem em que os objetivos e as fases de construção são chamados. Por exemplo, considere o comando abaixo. oclean e package argumentos são fases de construção, enquanto o dependency:copy-dependencies é uma meta.

mvn clean dependency:copy-dependencies package

Aqui, a fase de limpeza será executada primeiro, seguida peladependency:copy-dependencies goale, finalmente , a fase do pacote será executada.

Ciclo de vida limpo

Quando executamos o comando mvn pós-limpeza , o Maven invoca o ciclo de vida de limpeza que consiste nas seguintes fases.

  • pre-clean
  • clean
  • post-clean

A meta de limpeza do Maven (clean: clean) está vinculada à fase de limpeza no ciclo de vida limpo. Estáclean:cleangoalexclui a saída de uma construção excluindo o diretório de construção. Portanto, quando o comando mvn clean é executado, o Maven exclui o diretório de construção.

Podemos personalizar esse comportamento mencionando objetivos em qualquer uma das fases acima do ciclo de vida limpo.

No exemplo a seguir, vamos anexar maven-antrun-plugin: run goal às fases de pré-limpeza, limpeza e pós-limpeza. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida limpo.

Criamos um 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>
   <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>pre-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.clean</id>
                  <phase>clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.post-clean</id>
                  <phase>post-clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn post-clean

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

[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-clean}]
[INFO] Executing tasks
[echo] pre-clean phase
[INFO] Executed tasks
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] [antrun:run {execution: id.post-clean}]
[INFO] Executing tasks
[echo] post-clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: > 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------

Você pode tentar afinar mvn clean comando, que exibirá pre-cleanE limpo. Nada será executado porpost-clean fase.

Ciclo de vida padrão (ou construção)

Este é o ciclo de vida principal do Maven e é usado para construir o aplicativo. Tem as seguintes 21 fases.

Sr. Não. Fase e descrição do ciclo de vida
1

validate

Valida se o projeto está correto e todas as informações necessárias estão disponíveis para concluir o processo de construção.
2

initialize

Inicializa o estado de construção, por exemplo definir propriedades.
3

generate-sources

Gere qualquer código-fonte a ser incluído na fase de compilação.
4

process-sources

Processe o código-fonte, por exemplo, filtre qualquer valor.
5

generate-resources

Gere recursos a serem incluídos no pacote.
6

process-resources

Copie e processe os recursos no diretório de destino, pronto para a fase de empacotamento.
7

compile

Compile o código fonte do projeto.
8

process-classes

Pós-processe os arquivos gerados a partir da compilação, por exemplo, para fazer aprimoramento / otimização de bytecode em classes Java.
9

generate-test-sources

Gere qualquer código-fonte de teste a ser incluído na fase de compilação.
10

process-test-sources

Processe o código-fonte de teste, por exemplo, filtre quaisquer valores.
11

test-compile

Compile o código-fonte do teste no diretório de destino do teste.
12

process-test-classes

Processe os arquivos gerados a partir da compilação do arquivo de código de teste.
13

test

Execute testes usando uma estrutura de teste de unidade adequada (Junit é uma delas).
14

prepare-package

Execute todas as operações necessárias para preparar um pacote antes da embalagem real.
15

package

Pegue o código compilado e empacote-o em seu formato distribuível, como um arquivo JAR, WAR ou EAR.
16

pre-integration-test

Execute as ações necessárias antes que os testes de integração sejam executados. Por exemplo, configurando o ambiente necessário.
17

integration-test

Processe e implante o pacote, se necessário, em um ambiente onde os testes de integração possam ser executados.
18

post-integration-test

Execute as ações necessárias após a execução dos testes de integração. Por exemplo, limpar o meio ambiente.
19

verify

Execute qualquer verificação para verificar se o pacote é válido e atende aos critérios de qualidade.
20

install

Instale o pacote no repositório local, que pode ser usado como uma dependência em outros projetos localmente.
21

deploy

Copia o pacote final para o repositório remoto para compartilhamento com outros desenvolvedores e projetos.

Existem alguns conceitos importantes relacionados ao Maven Lifecycles, que vale a pena mencionar -

  • Quando uma fase é chamada via comando Maven, por exemplo mvn compile, apenas as fases até e incluindo essa fase serão executadas.

  • Diferentes objetivos do maven serão vinculados a diferentes fases do ciclo de vida do Maven, dependendo do tipo de embalagem (JAR / WAR / EAR).

No exemplo a seguir, vamos anexar maven-antrun-plugin: run goal a algumas das fases do ciclo de vida do Build. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida.

Atualizamos 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>
   <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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn compile

O Maven iniciará o processamento e exibirá as fases do ciclo de vida da construção até a fase de compilação.

[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [compile]
[INFO] -----------------------------------------------------------------
-
[INFO] [antrun:run {execution: id.validate}]
[INFO] Executing tasks
[echo] validate phase
[INFO] Executed tasks
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered
resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory
C:\MVN\project\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [antrun:run {execution: id.compile}]
[INFO] Executing tasks
[echo] compile phase
[INFO] Executed tasks
[INFO] -----------------------------------------------------------------
-
[INFO] BUILD SUCCESSFUL
[INFO] -----------------------------------------------------------------
-
[INFO] Total time: 2 seconds
[INFO] Finished at: Sat Jul 07 20:18:25 IST 2012
[INFO] Final Memory: 7M/64M
[INFO] -----------------------------------------------------------------
-

Ciclo de Vida do Site

O plugin do site Maven é geralmente usado para criar documentação nova para criar relatórios, implantar o site, etc. Ele tem as seguintes fases -

  • pre-site
  • site
  • post-site
  • site-deploy

No exemplo a seguir, vamos anexar maven-antrun-plugin:runobjetivo para todas as fases do ciclo de vida do site. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida.

Atualizamos 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>
   <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-site</id>
                  <phase>pre-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>pre-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site</id>
                  <phase>site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.post-site</id>
                  <phase>post-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site-deploy</id>
                  <phase>site-deploy</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site-deploy phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn site

O Maven começará a processar e exibir as fases do ciclo de vida do site até a fase do site.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [site]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-site}]
[INFO] Executing tasks
[echo] pre-site phase
[INFO] Executed tasks
[INFO] [site:site {execution: default-site}]

[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Project Plugins" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.

[INFO] [antrun:run {execution: id.site}]
[INFO] Executing tasks
[echo] site phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sat Jul 07 15:25:10 IST 2012
[INFO] Final Memory: 24M/149M
[INFO] ------------------------------------------------------------------
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved