Saltar a contenido

Apache Maven


Apache Maven es una herramienta que nos permitir compilar y ensamblar un proyecto de desarrollo tipo Java, solo requiere tener Oracle Java JDK instalado.

Para la mayoría de proyectos actuales se recomienda tener:

Instalación

Para la instalación de Apache Maven solo basta con descargar el archivo de Maven deseado y descomprimirlo dentro de una carpeta, e incluirlo dentro del PATH.

Otra opción es usar SDKMAN, sólo se teclea sdk i maven:

$ sdk i maven

Downloading: maven 3.5.4

In progress...
...
######################################################### 100.0%

Installing: maven 3.5.4
Done installing!

Setting maven 3.5.4 as default.

Por último es recomendable es usar Maven Wrapper para su instalación en ambientes Windows.

Uso

Se recomienda leer la documentación en linea de Apache Maven pero si se tiene prisa se recomienda leer las siguientes ligas:

Una ves instalado se puede validar si Maven está corriendo con el comando mvn para ver la versión instalada como se ve en el ejemplo:

$ mvn --version
Apache Maven 3.5.4 (... 2018-06-17T13:33:14-05:00)
Maven home: /home/user/.sdkman/candidates/maven/current
Java version: 1.8.0_171, vendor: Oracle Corporation, runtime: .../jre
Default locale: es_MX, platform encoding: UTF-8
OS name: "linux", version: "4.12-default", arch: "amd64", family: "unix"

Maven funciona con base en plugins, por lo que se recomienda leer su documentación para mayor información.

Creación de archivo POM

Cada proyecto de Java que queramos compilar y ensamblar con Maven, será necesario crear un archivo pom.xml que es el que va a contener la información necesaria para nuestro proyecto.

Este se puede crear con cualquier editor o podemos generar uno a partir de un arquetipo archetype de los que Maven dispone

$ mvn archetype:generate -DgroupId=test.mx -DartifactId=myApp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>>maven-archetype-plugin:3.0.1:generate (default-cli) > generate-sources @ standalone-pom>>>
[INFO]
[INFO] <<<maven-archetype-plugin:3.0.1:generate (default-cli) < generate-sources @ standalone-pom<<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.0.1:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
.....
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: test.mx
[INFO] Parameter: packageName, Value: test.mx
[INFO] Parameter: package, Value: test.mx
[INFO] Parameter: artifactId, Value: myApp
[INFO] Parameter: basedir, Value: /home/proyectos
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /home/proyectos/myApp
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 19.559 s
[INFO] Finished at: 2018-04-26T12:20:08-05:00
[INFO] ------------------------------------------------------------------------

Esto nos genera un directorio llamada con el nombre del parámetro artifactId para este caso myApp y dentro de este directorio se crea una estructura que contiene lo siguiente:

$ ls -l
total 4
drwxr-xr-x 3 user users 4096 abr 26 12:20 myApp
$ cd myApp/
$ ls -l
total 8
-rw-r--r-- 1 user users  634 abr 26 12:20 pom.xml
drwxr-xr-x 4 user users 4096 abr 26 12:20 src

El detalle de esta estructura es la siguiente:

myApp
|-- pom.xml
`-- src
    |-- main
    |   `-- java
    |       `-- mx
    |           `-- test
    |               `-- java
    |                   `-- App.java
    `-- test
        `-- java
            `-- mx
                `-- test
                    `-- java
                        `-- AppTest.java

El directorio src/main/java contiene el código fuente del proyecto, el directorio src/test/java contiene el origen de la prueba y el archivo pom.xml es el Modelo de Objetos del Proyecto o POM(Project Object Model).

Archivo POM

El archivo pom.xml es el núcleo de la configuración de un proyecto en Maven. Es un archivo de configuración único que contiene la mayoría de la información requerida para crear un proyecto de la manera que se desee. El POM puede ser grande y desalentar en su complejidad, pero la creación de este archivo es al inicio y solo se va actualizando según las necesidades, por lo que facilita en gran medida la labor de compilación y ensamblado de un proyecto.

El POM de este proyecto es:

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>mx.test.java</groupId>
  <artifactId>myApp</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>myApp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Ensamblado de Proyecto

Para empezar a compilar y ensamblar un proyecto basta con ejecutar el siguiente comando mvn package, se recomienda limpiar el proyecto cada vez que se empaqueta por lo que el comando quedaría como mvn clean package

$ mvn clean package
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< mx.test.java:myApp >------------------------
[INFO] Building myApp 1.0-SNAPSHOT
[INFO] ----------------------------[ jar ]-------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ myApp ---
[INFO]
......
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running mx.test.java.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.002 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myApp ---
[INFO] Building jar: /home/proyectos/myApp/target/myApp-1.0-SNAPSHOT.jar
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -------------------------------------------------------------------
[INFO] Total time: 20.156 s
[INFO] Finished at: 2018-04-26T12:38:36-05:00
[INFO] -------------------------------------------------------------------

Este simple comando nos indica que se ejecuta una o una serie de fases, para este caso clean & package. Una fase es un paso en el ciclo de vida de compilación, que es una secuencia ordenada de fases. Cuando se da una fase, Maven ejecutará cada fase de la secuencia hasta e incluyendo la definida. Por ejemplo, si ejecutamos la fase de compilación, las fases que realmente se ejecutan son:

  1. validar
  2. generar-fuentes
  3. proceso-fuentes
  4. generar recursos
  5. recursos de proceso
  6. compilar

Podemos probar el programa recién compilado y empaquetado JAR con el siguiente comando:

$ java -cp target/myApp-1.0-SNAPSHOT.jar mx.test.java.App
Hello World!

Fases

Aunque no es una lista exhaustiva, estas son las fases de ciclo de vida predeterminadas más comunes ejecutadas.

  • validate - validate el proyecto es correcto y toda la información necesaria está disponible
  • compile - compilar el código fuente del proyecto
  • test - pruebe el código fuente compilado usando un marco de prueba de unidad adecuado. Estas pruebas no deberían requerir que el código sea empaquetado o implementado
  • paquete - tome el código compilado y empaquételo en su formato distribuible, como un JAR.
  • integration-test - procesa e implemente el paquete si es necesario en un entorno donde se puedan ejecutar pruebas de integración
  • verify - ejecutar todos los controles para verificar que el paquete sea válido y cumpla con los criterios de calidad
  • install - instale el paquete en el repositorio local, para usarlo como dependencia en otros proyectos a nivel local
  • deploy - hecho en un entorno de integración o lanzamiento, copia el paquete final en el repositorio remoto para compartirlo con otros desarrolladores y proyectos.

Hay otros dos ciclos de vida de Maven de nota más allá de la lista predeterminada anterior, y son:

  • clean - limpia los artefactos creados por compilaciones anteriores, se re quiere cuando hay problemas en el empaquetado
  • site - genera documentación del sitio para este proyecto

Las fases en realidad están mapeadas a los objetivos secundarios. Los objetivos específicos ejecutados por cada fase dependen del tipo de paquete del proyecto. Por ejemplo, el paquete ejecuta jar:jar si el tipo de proyecto es un JAR y war:war si el tipo de proyecto es, lo adivinaste, un WAR.

Algo interesante de notar es que las fases y los objetivos se pueden ejecutar en secuencia.

Tips

Algunos de los comandos más usados:

Limpieza y compilación:

mvn clean compile

Instalación en el repositorio local .m2:

mvn install

Instalación en el Artifactory:

mvn deploy

Dependencias:

mvn dependency:tree > tree.txt

Revisión de Test por Cobertura:

mvn -DskipTests.core=false cobertura:cobertura -Dcobertura.report.format=xml

Revisión de Test por Jacoco:

mvn -DskipTests.core=false jacoco:report

Lista de versiones de librerías:

mvn versions:display-dependency-updates > update.txt