Comprender Manven [02]

El Project Object Model es un archivo xml(pom.xml) que cada proyecto posee y el cual describe la configuración de los plugins, las dependencias o librerías de terceros, los perfiles y más.

Este xml es usado por maven para realizar la construcción(build) del proyecto cada vez que ejecutamos algún goal o una fase del ciclo de vida.

Contiene un elemento padre llamado <project>...</project> y este a su vez otros subelementos. De todos los elementos el POM al menos debe tener las coordenadas que identifican al proyecto. Que son las coordenadas?

Coordenadas Maven

Los elementos groupId, artifactId y version son identificadores que forman lo que se denomina coordenadas de un proyecto. Estas coordenadas son únicas y no existen dos proyectos con los mismos valores en groupId, artifactId y version.

Se le denomina coordenadas porque se asemeja a tener una dirección o ubicación única para un proyecto dentro del espacio de proyectos Maven. Esta es la forma en que maven relaciona proyectos entre sí. Los repositorios Maven están organizados usando estos identificadores.

El elemento groupId

Representa un grupo, empresa, equipo u organización. Generalmente se nombra empezando con un dominio y la organización que crea el proyecto ej: org.miempresa.

El elemento artifactId

Representa de manera única el nombre ya sea del del proyecto completo o de un módulo de este.

El elemento version

Representa la versión de este proyecto o de este módulo. Bajo desarrollo suele usarse un número más la palabra SNAPSHOT.

El elemento packaging

Representa la forma en que se va a distribuir la aplicación. Si no se coloca este elemento por defecto es JAR. También existe WAR, EJB, POM y otros. Aunque packaging es un elemento de las coordenadas, no es parte de los identificadores únicos de un proyecto.

Los siguientes son los elementos que puede contener un pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<project ...></span>
  <modelVersion>4.0.0</modelVersion>

<!-- Básicos -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <dependencies>...</dependencies>
  <parent>...</parent>
  <dependencyManagement>...</dependencyManagement>
  <modules>...</modules>
  <properties>...</properties>

<!-- Configuración para construcción(build) -->
  <build>...</build>
  <reporting>...</reporting>

<!-- Otras información del proyecto -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>

<!-- Configurcion de entorno -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

Mientras vayamos haciendo ejemplos veremos la mayoría de estos elementos. Este es un pom básico generado por maven:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<project... >

  <modelVersion>4.0.0</modelVersion>
  <groupId>net.ejemplos.ejemplomaven</groupId>
  <artifactId>ejemplo-maven</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>

  <name>ejemplo-maven</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>

Ahora hagamos un ejemplo. Vamos a crear un pequeño proyecto y compilarlo. Usaremos dos plugins:

1. archetype:generate para generar el proyecto.
2. compiler:compile para compilarlo.

Arquetipos

En Maven un arquetipo básicamente es un modelo. Como una especie de molde para crear los proyectos. Los arquetipos crean un proyecto agregando características específicas como: que directorios hacen parte de la estructura o que elementos son incluidos en el pom. Vamos a usar el arquetipo maven-archetype-quickstart que crea un proyecto muy básico.

Cremos el Proyecto

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false -DgroupId=org.empresa.proyecto -DartifactId=proyecto1

Esto crea una estructura como esta:

proyecto1
 ├─ pom.xml
 └─ src
     ├─ main
     │   └─ java
     │       └─ org
     │           └─ empresa
     │               └─ proyecto
     │                   └─ App.java
     └─ test
         └─ java
             └─ org
                 └─ empresa
                     └─ proyecto
                         └─ AppTest.java

Compilamos el Proyecto

mvn compiler:compile

Esto crea un nuevo directorio para el proyecto generado llamado target y un subdirectorio en target llamado classes.

Ejecutamos el Proyecto

java -cp target/classes org.empresa.proyecto.App

No te gustan esos nombres de directorio? Bueno hagamos nuestra primera configuracion en el pom.xml generado.

Limpiar el proyecto generado:

mvn clean

Agregamos al pom.xml:

1
2
3
<build>
  <directory>build</directory>
</build>

Compilamos de nuevo:

mvn compiler:compile

Ahora ya no vemos que genera el directorio target si no build. Así configuramos muchas cosas en el pom.xml para cambiar el comportamiento de los plugins.

Usando el Ciclo de Vida

En vez de usar plugins directamente para compilar usemos el ciclo de vida. Quitamos la configuración el elemento que colocamos en el pom.xml y ejecutamos:

mvn install

Esto crea el directorio target con varios subdirectorios y el nombre del empaquetado del proyecto, en este caso: proyecto1-1.0-SNAPSHOT.jar