Configuración de archivos de construcción de Maven POM de Maven

Ciclo de construcción de Maven

El ciclo de vida de construcción de Maven define el proceso de construcción y lanzamiento de un proyecto.

Un ciclo de vida de construcción (build) típico de Maven está compuesto por una secuencia de las siguientes fases:

Fase	Tratamiento	descripción
Verificar validate	Verificar el proyecto	Verificar si el proyecto es correcto y toda la información necesaria está disponible
Compilar compile	Ejecutar compilación	La compilación del código fuente se completa en esta fase
Pruebas Test	Pruebas	Ejecutar pruebas utilizando el marco de pruebas unitarias adecuado (por ejemplo, JUnit)
Empaquetar package	Empaquetar	Crear JAR/El paquete WAR, si se menciona en el paquete definido en pom.xml
Revisión verify	Revisión	Revisar los resultados de las pruebas integradas para garantizar que cumplan con los estándares de calidad
Instalación install	Instalación	Instalar el proyecto empacado en el repositorio local para que otros proyectos puedan usarlo
Despliegue deploy	Despliegue	Copiar el paquete de proyecto final a un repositorio remoto para compartirlo con otros desarrolladores y proyectos

Para completar el ciclo de vida default, estas fases (incluidas otras fases de ciclo de vida no enumeradas aquí) se ejecutarán en orden.

Maven tiene los siguientes tres ciclos de vida estándar:

clean: Tratamiento de la limpieza del proyecto
default (o build): Tratamiento del despliegue del proyecto
site: Tratamiento de la creación de documentos del sitio del proyecto

Las fases de construcción están compuestas por objetivos de plugin

Un objetivo de plugin representa una tarea específica (más fina que la fase de construcción), lo que ayuda en la construcción y gestión del proyecto. Estos objetivos pueden estar asociados con múltiples fases o sin asociación. Los objetivos no asociados con ninguna fase de construcción se pueden ejecutar directamente fuera del ciclo de vida de construcción. El orden de ejecución de estos objetivos depende del orden de llamada del objetivo y de la fase de construcción.

Por ejemplo, considere el siguiente comando:

clean y pakage son fases de construcción, dependency:copy-dependencies es el objetivo

mvn clean dependency:copy-dependencies package

La fase de limpiar aquí se ejecutará primero, seguida de dependency:copy-Las dependencias objetivo se ejecutarán, y finalmente se ejecutará el paquete.

Ciclo de vida Clean

Cuando ejecutamos mvn post-Al ejecutar el comando clean, Maven llama al ciclo de vida clean, que contiene las siguientes etapas:

pre-clean: ejecutar algunas tareas que deben realizarse antes de clean
clean: eliminar todos los archivos generados por la última construcción
post-clean: ejecutar algunas tareas que deben realizarse inmediatamente después de clean

El clean en mvn clean es el clean mencionado anteriormente. En un ciclo de vida, al ejecutar una etapa, todas las etapas anteriores se ejecutarán, es decir, si se ejecuta mvn clean se ejecutarán las siguientes dos etapas del ciclo de vida:

pre-clean, clean

Si ejecutamos mvn post-si ejecutamos clean, se ejecutarán las siguientes tres etapas del ciclo de vida:

pre-clean, clean, post-clean

Podemos modificar el comportamiento de esta sección modificando el objetivo definido en cualquier etapa del ciclo de vida de clean.

En el siguiente ejemplo, utilizaremos maven-antrun-el objetivo plugin:run se agrega a pre-clean, clean y post-en la etapa de clean. De esta manera, podemos mostrar información de texto en todas las etapas del ciclo de vida de clean.

Hemos creado un archivo pom.xml en el directorio 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>
<versión>1.0</versión>
<construcción>
<plugins>
　　　<plugin>
　　　<groupId>org.apache.maven.plugins</groupId>
　　　<artifactId>maven-antrun-plugin</artifactId>
　　　<versión>1.1</versión>
　　　<ejecuciones>
　　　　　　<ejecución>
　　　　　　　　　<id>id.pre-clean</id>
　　　　　　　　　<fase>pre-clean</fase>
　　　　　　　　　<objetivos>
　　　　　　　　　　　　<objetivo>run</objetivo>
　　　　　　　　　</objetivos>
　　　　　　　　　<configuración>
　　　　　　　　　　　　<tareas>
　　　　　　　　　　　　　　　<echo>pre-etapa de clean</echo>
　　　　　　　　　　　　</tareas>
　　　　　　　　　</configuración>
　　　　　　</execution>
　　　　　　<ejecución>
　　　　　　　　　<id>id.clean</id>
　　　　　　　　　<phase>clean</fase>
　　　　　　　　　<objetivos>
　　　　　　　　　　<objetivo>run</objetivo>
　　　　　　　　　</objetivos>
　　　　　　　　　<configuración>
　　　　　　　　　　　　<tareas>
　　　　　　　　　　　　　　　<echo>etapa de clean</echo>
　　　　　　　　　　　　</tareas>
　　　　　　　　　</configuración>
　　　　　　</execution>
　　　　　　<ejecución>
　　　　　　　　　<id>id.post-clean</id>
　　　　　　　　　<fase>post-clean</fase>
　　　　　　　　　<objetivos>
　　　　　　　　　　　　<objetivo>run</objetivo>
　　　　　　　　　</objetivos>
　　　　　　　　　<configuración>
　　　　　　　　　　　　<tareas>
　　　　　　　　　　　　　　　<echo>post-etapa de clean</echo>
　　　　　　　　　　　　</tareas>
　　　　　　　　　</configuración>
　　　　　　</execution>
　　　</executions>
　　　</plugin>
</plugins>
</build>
</project>

Ahora abre la consola de comandos, cambia al directorio donde se encuentra pom.xml y ejecuta el siguiente comando mvn.

C:\MVN\project>mvn post-clean

Maven comenzará a procesar y mostrar todas las etapas del ciclo de vida de clean.

[INFO]　Escaneando　por　proyectos...
[INFO]　------------------------------------------------------------------
[INFO]　Construyendo　Unnamed　-　com.companyname.projectgroup:project:jar:1.0
[INFO]　　　　tarea-segmento: [post-clean]
[INFO]　------------------------------------------------------------------
[INFO]　[antrun:run　{execution:　id.pre-clean}]
[INFO] Ejecutando tareas
　　　　　[echo]　pre-etapa de clean
[INFO] Tareas ejecutadas
[INFO] [clean:clean {execution: default}-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Ejecutando tareas
　　　　　[echo] etapa de clean
[INFO] Tareas ejecutadas
[INFO] [antrun:run {execution: id.post}-clean}]
[INFO] Ejecutando tareas
　　　　　[echo] post-etapa de clean
[INFO] Tareas ejecutadas
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO]　------------------------------------------------------------------
[INFO] Tiempo total: <　1　segundo
[INFO] Finalizado en: Sáb Jul 07　13:38:59　IST　2012
[INFO] Memoria final:　4M/44M
[INFO]　------------------------------------------------------------------

Puedes intentar modificar el comando mvn clean para mostrar pre-clean y clean, y en post-La etapa de clean no ejecuta ninguna operación.

Ciclo de vida (Compilación) por defecto

Este es el ciclo de vida principal de Maven, utilizado para construir aplicaciones, incluyendo lo siguiente. 23 etapa:

etapa de ciclo de vida	descripción
validate (validar)	Validar si el proyecto es correcto y toda la información necesaria puede completar el proceso de construcción del proyecto.
initialize (inicializar)	Inicializar el estado de construcción, como establecer valores de propiedades.
generate-sources (generar el código fuente)	Generar cualquier código fuente que se incluya en la fase de compilación.
process-sources (procesar el código fuente)	Procesar el código fuente, por ejemplo, filtrar cualquier valor.
generate-resources (generar archivos de recursos)	Generar los archivos de recursos que se incluirán en el paquete del proyecto.
process-resources (procesar archivos de recursos)	Copiar y procesar los recursos al directorio de destino, preparando así el mejor entorno para la fase de empaquetado.
compile (compilar)	Compilar el código fuente del proyecto.
process-classes (procesar archivos de clase)	Procesar los archivos generados por la compilación, por ejemplo, optimizar el bytecode de los archivos Java class.
generate-test-sources (generar el código fuente de pruebas)	Generar cualquier código fuente de prueba que se incluya en la fase de compilación.
process-test-sources (procesar el código fuente de pruebas)	Procesar el código fuente de pruebas, por ejemplo, filtrar cualquier valor.
generate-test-resources (generar archivos de recursos)	Crear archivos de recursos para las pruebas.
process-test-resources (procesar archivos de recursos de prueba)	Copiar y procesar los recursos de pruebas al directorio de destino.
test-compile (compilar el código fuente de pruebas)	Compilar el código fuente de pruebas al directorio de destino de pruebas.
process-test-classes (procesar archivos de clase de prueba)	Procesar los archivos generados por la compilación de pruebas.
test (pruebas)	Ejecutar pruebas utilizando un marco de prueba de unidad adecuado (Juint es uno de ellos).
prepare-package (preparar el empaquetado)	Ejecutar cualquier operación necesaria para preparar el empaquetado antes de hacerlo.
package (empaquetar)	Empaquetar el código compilado en un formato distribuido, como archivos JAR, WAR o EAR.
pre-integration-test (antes de la prueba de integración)	Realizar las acciones necesarias antes de ejecutar las pruebas de integración. Por ejemplo, configurar el entorno necesario.
integration-test (prueba de integración)	Procesar y desplegar el proyecto en un entorno que pueda ejecutar pruebas de integración.
post-integration-test (después de la prueba de integración)	Realizar las acciones necesarias después de completar las pruebas de integración. Por ejemplo, limpiar el entorno de pruebas de integración.
verify (verificar)	Ejecutar cualquier comprobación para verificar que el paquete de proyecto sea válido y cumpla con los estándares de calidad.
install (instalar)	Instalar el paquete de proyecto en el repositorio local, de modo que el paquete de proyecto pueda usarse como dependencia de otros proyectos locales.
deploy (desplegar)	Copiar el paquete de proyecto final en el repositorio remoto para compartirlo con otros desarrolladores y proyectos.

Existen algunos conceptos importantes relacionados con el ciclo de vida de Maven que necesitan ser explicados:

cuando se llama a una etapa mediante el comando de Maven, por ejemplo mvn compile, solo se ejecutarán todas las etapas anteriores e inclusas la etapa en sí.

los objetivos de Maven diferentes se ejecutarán según el tipo de paquete (JAR / WAR / EAR), está asociado con diferentes etapas del ciclo de vida de Maven.

En el siguiente ejemplo, utilizaremos maven-antrun-plugin:ejecutar el objetivo se agrega a una etapa de la vida del ciclo de construcción. De esta manera, podemos mostrar la información de texto del ciclo de vida.

Hemos actualizado el archivo pom.xml en el directorio 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>
<versión>1.0</versión>
<construcción>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<versión>1.1</versión>
<ejecuciones>
　　　<ejecución>
　　　　　　<id>id.validación</id>
　　　　　　<fase>validación</fase>
　　　　　　<objetivos>
　　　　　　　　　<objetivo>run</objetivo>
　　　　　　</objetivos>
　　　　　　<configuración>
　　　　　　　　　<tareas>
　　　　　　　　　　　　<echo> fase de validación</echo>
　　　　　　　　　</tareas>
　　　　　　</configuración>
　　　</execution>
　　　<ejecución>
　　　　　　<id>id.compilación</id>
　　　　　　<fase>compilación</fase>
　　　　　　<objetivos>
　　　　　　　　　<objetivo>run</objetivo>
　　　　　　</objetivos>
　　　　　　<configuración>
　　　　　　　　　<tareas>
　　　　　　　　　　　　<echo> fase de compilación</echo>
　　　　　　　　　</tareas>
　　　　　　</configuración>
　　　</execution>
　　　<ejecución>
　　　　　　<id>id.prueba</id>
　　　　　　<fase>prueba</fase>
　　　　　　<objetivos>
　　　　　　　　　<objetivo>run</objetivo>
　　　　　　</objetivos>
　　　　　　<configuración>
　　　　　　　　　<tareas>
　　　　　　　　　　　　<echo> fase de prueba</echo>
　　　　　　　　　</tareas>
　　　　　　</configuración>
　　　</execution>
　　　<ejecución>
　　　　　　　　　<id>id.paquete</id>
　　　　　　　　　<fase>paquete</fase>
　　　　　　　　　<objetivos>
　　　　　　　　　　　　<objetivo>run</objetivo>
　　　　　　　　　</objetivos>
　　　　　　　　　<configuración>
　　　　　　　　　<tareas>
　　　　　　　　　　　　<echo> fase de paquete</echo>
　　　　　　　　　</tareas>
　　　　　　</configuración>
　　　</execution>
　　　<ejecución>
　　　　　　<id>id.despliegue</id>
　　　　　　<fase>despliegue</fase>
　　　　　　<objetivos>
　　　　　　　　　<objetivo>run</objetivo>
　　　　　　</objetivos>
　　　　　　<configuración>
　　　　　　<tareas>
　　　　　　　　　<echo> fase de despliegue</echo>
　　　　　　</tareas>
　　　　　　</configuración>
　　　</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Ahora　abre　la　consola　de　comandos，ve　al　directorio　donde　se　encuentra　pom.xml　y　ejecuta　el　siguiente　comando　mvn.

C:\MVN\project>mvn compile

Maven comenzará a procesar y mostrar todas las etapas del ciclo de vida de construcción hasta la etapa de compilación.

[INFO]　Escaneando　por　proyectos...
[INFO]　------------------------------------------------------------------
[INFO]　Construyendo　Unnamed　-　com.companyname.projectgroup:project:jar:1.0
[INFO]　　　　tarea-segmento: [compilar]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:ejecutar {ejecución: id.validate}
[INFO] Ejecutando tareas
　　　　　[echo] fase de validación
[INFO] Tareas ejecutadas
[INFO] [recursos:recursos {ejecución: default-resources}]
[ADVERTENCIA] Usando codificación de plataforma (Cp1252　realmente) copiar los recursos filtrados,
es decir, la construcción depende de la plataforma!
[INFO] omitir el directorio de recursos no existente C:\MVN\project\src\main\resources
[INFO] [compilador:compile {ejecución: default-compile}]
[INFO] No hay nada que compilar　-　todas las clases están actualizadas
[INFO]　[antrun:run　{execution:　id.compile}]
[INFO] Ejecutando tareas
　　　　　[echo]　compile　phase
[INFO] Tareas ejecutadas
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO]　------------------------------------------------------------------
[INFO] Tiempo total:　2　segundos
[INFO] Finalizado en: Sáb Jul 07　20:18:25　IST　2012
[INFO] Memoria final:　7M/64M
[INFO]　------------------------------------------------------------------

Llamada de línea de comandos

En el entorno de desarrollo, se utiliza el siguiente comando para construir e instalar el proyecto en el repositorio local

mvn　install

Este comando ejecuta en orden las etapas del ciclo de vida default (validar, compilar, empacar, etc.) antes de ejecutar la etapa install, solo necesitamos llamar a la última etapa, como aquí, install.

En el entorno de construcción, se utiliza la siguiente llamada para construir y desplegar el proyecto en el repositorio compartido de manera pura

mvn　clean　deploy

Esta línea de comando también se puede usar en el caso de múltiples módulos, es decir, proyectos que contienen múltiples subproyectos, Maven ejecutará el comando clean en cada subproyecto y luego el comando deploy.

Ciclo de vida Site

El plugin Maven Site generalmente se utiliza para crear nuevos documentos de informe, desplegar sitios, etc.

pre-site: realizar algunas tareas que deben completarse antes de generar los documentos del sitio
site: generar los documentos del sitio del proyecto
post-site: realizar algunas tareas que deben completarse después de generar los documentos del sitio, y prepararse para el despliegue
site-deploy: desplegar los documentos del sitio generado en un servidor específico

Aquí se utiliza con frecuencia la etapa site y site-la etapa deploy, para generar y publicar el sitio web de Maven, que es una función bastante poderosa de Maven, a la que el Manager le gusta mucho, la generación automática de documentos y estadísticas, muy bonitos. En el siguiente ejemplo, utilizaremos maven-antrun-Se añadió el objetivo plugin:run a todas las etapas del ciclo de vida de Site. De esta manera, podemos mostrar toda la información de texto del ciclo de vida.