3. Las herramientas del documento
Los ejemplos de este documento se han probado con las siguientes herramientas:
- NetBeans, desde la versión 6.8 hasta la versión 7.1.2. La instalación de NetBeans se describe en [ref3], en el párrafo 1.3.1.
- Wampserver, versión 2.2. La instalación de WampServer se describe en [ref3], en el párrafo 1.3.3;
- Maven está integrado en NetBeans. A continuación describimos esta herramienta.
3.1. Maven
3.1.1. Introducción
Maven está disponible en URL [http://maven.apache.org/index.html ]. Según sus creadores:
El objetivo principal de Maven es permitir que un desarrollador comprenda el estado completo de un proyecto de desarrollo en el menor tiempo posible. Para alcanzar este objetivo, hay varias áreas de interés que Maven intenta abordar:
- Facilitar el proceso de compilación
- Proporcionar un sistema de compilación uniforme
- Proporcionar información de calidad sobre el proyecto
- Proporcionar directrices para el desarrollo de mejores prácticas
- Permitir una migración transparente a nuevas funcionalidades
Maven está integrado en NetBeans y lo utilizaremos solo para una de sus características: la administración de las bibliotecas de un proyecto. Estas están formadas por el conjunto de archivos jars que deben estar en el directorio Classpath del proyecto. Pueden ser muy numerosas. Por ejemplo, nuestros proyectos futuros utilizarán el ORM (mapeador objeto-relacional) Hibernate. Este ORM está compuesto por decenas de archivos jar. La ventaja de Maven es que nos libera de tener que conocerlas todas. Solo tenemos que indicar en nuestro proyecto que necesitamos Hibernate, proporcionando toda la información necesaria para encontrar el archivo principal de este ORM. Maven descarga entonces también todas las bibliotecas necesarias para Hibernate. A esto se le llama las dependencias de Hibernate. Una biblioteca necesaria para Hibernate puede depender a su vez de otros archivos. Estos también se descargarán. Todas estas bibliotecas se colocan en una carpeta llamada el repositorio local de Maven.
Un proyecto de Maven se puede compartir fácilmente. Si se transfiere de una computadora a otra y las dependencias del proyecto no están presentes en el repositorio local de la nueva computadora, se descargarán.
Maven se puede utilizar de forma independiente o integrado en un EDI (Entorno de Desarrollo Integrado) como NetBeans o Eclipse.
Creemos un proyecto de Maven en NetBeans:
 |
- en [1], crear un nuevo proyecto,
- en [2], elige la categoría [Maven] y el tipo de proyecto [Java Application],
 |
- en [3], designa la carpeta principal de la carpeta del nuevo proyecto,
- en [4], asigne un nombre al proyecto,
- en [5], el proyecto generado.
Analicemos los elementos del proyecto y expliquemos la función de cada uno.
 |
- en [1]: las diferentes ramas del proyecto:
- [Source packages]: las clases Java del proyecto;
- [Test packages]: las clases de prueba del proyecto;
- [Dependencies]: los archivos .jar necesarios para el proyecto y administrados por Maven;
- [Test Dependencies]: los archivos .jar necesarios para las pruebas del proyecto y administrados por Maven;
- [Java Dependencies]: los archivos .jar necesarios para el proyecto y que no son administrados por Maven;
- [Project Files]: archivos de configuración de Maven y NetBeans,
 |
- en [3], la rama [Source Packages],
Esta rama contiene los códigos fuente de las clases Java del proyecto. NetBeans generó una clase por defecto:
package istia.st.mvexemple;
/**
* Hello world!
*
*/
public class App {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
 |
- en [4], la rama [Test Packages], que contiene el código fuente de las clases de prueba del proyecto,
- en [5], la biblioteca JUnit 3.8 necesaria para ejecutar las pruebas,
NetBeans generó una clase por defecto:
package istia.st.mvexemple;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest extends TestCase {
/**
* Create the test case
*
* @param testName
* name of the test case
*/
public AppTest(String testName) {
super(testName);
}
/**
* @return the suite of tests being tested
*/
public static Test suite() {
return new TestSuite(AppTest.class);
}
/**
* Rigourous Test :-)
*/
public void testApp() {
assertTrue(true);
}
}
Se trata de una prueba JUnit 3.8. Posteriormente utilizaremos pruebas JUnit 4.x.
 |
- En [6], la rama [Dependencies] está vacía aquí,
Esta rama muestra todas las bibliotecas necesarias para el proyecto y administradas por Maven. Todas las bibliotecas que aparecen aquí son descargadas automáticamente por Maven. Por eso un proyecto de Maven necesita acceso a Internet. Las bibliotecas descargadas se almacenarán localmente. Si otro proyecto necesita una biblioteca que ya está presente localmente, esta no se descargará. Veremos que esta lista de bibliotecas, así como los repositorios donde se pueden encontrar, se definen en el archivo de configuración del proyecto Maven.
 |
- en [7], las bibliotecas necesarias para el proyecto y que no son administradas por Maven,
 |
- en [7], el archivo [pom.xml] de configuración del proyecto Maven. POM significa Project Object Model. Tendremos que modificar directamente este archivo.
El archivo [pom.xml] generado es el siguiente:
<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>istia.st</groupId>
<artifactId>mv-exemple</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mv-exemple</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
- Las líneas 5 a 8 definen el objeto (artefacto) Java que creará el proyecto Maven. Esta información proviene del asistente que se utilizó al crear el proyecto:
 |
Un objeto de Maven se define mediante cuatro propiedades:
- [groupId]: una información que se asemeja a un nombre de paquete. Así, las bibliotecas del marco Spring tienen groupId=org.springframework, las del marco JSF tienen groupId=javax.faces,
- [artifactId]: el nombre del objeto Maven. En el grupo [org.springframework] se encuentran, por lo tanto, los siguientes artifactId: spring-context, spring-core, spring-beans, ... En el grupo [javax.faces], se encuentra el artifactId jsf-api,
- [version]: número de versión del artefacto de Maven. Así, el artefacto org.springframework.spring-core tiene las siguientes versiones: 2.5.4, 2.5.5, 2.5.6, 2.5.6.SECO1, ...
- [packaging]: el formato que adopta el artefacto, que suele ser war o jar.
Nuestro proyecto Maven generará un [jar] (línea 8) dentro del grupo [istia.st] (línea 5), denominado [mv-exemple] (línea 6) y con la versión [1.0-SNAPSHOT] (línea 7). Estos cuatro datos deben definir de manera única un artefacto de Maven.
Las líneas 17 a 24 enumeran las dependencias del proyecto Maven, es decir, la lista de bibliotecas necesarias para el proyecto. Cada biblioteca se define mediante cuatro datos (groupId, artifactId, versión, empaquetado). Cuando falta la información packaging, como en este caso, se utiliza el archivo JAR packaging. Se agrega otra información, el alcance (scope), que determina en qué momentos del ciclo de vida del proyecto se necesita la biblioteca. El valor predeterminado es «compile», lo que indica que la biblioteca es necesaria tanto para la compilación como para la ejecución. El valor «test» significa que la biblioteca es necesaria durante las pruebas del proyecto. Este es el caso aquí con la biblioteca JUnit 3.8.1. Si esta biblioteca no se encuentra en el repositorio local de la estación de trabajo, se descarga.
3.1.2. Ejecución del proyecto
Ejecutamos el proyecto:
 |
En [1], se compila el proyecto Maven y luego se ejecuta [1]. Los registros en la consola de NetBeans son los siguientes:
El resultado se encuentra en la línea 23. Se observa que, incluso en este caso sencillo, Maven ha descargado algunos elementos (líneas 17 y 20).
3.1.3. El sistema de archivos de un proyecto Maven
 |
- [1]: el sistema de archivos del proyecto se encuentra en la pestaña [Files],
- [2]: los códigos fuente de Java se encuentran en la carpeta [src / main / java],
- [3]: los códigos fuente Java de las pruebas se encuentran en la carpeta [src / test / java],
- [4]: la carpeta [target] se crea durante la compilación (build) del proyecto,
- [5]: aquí, la compilación del proyecto ha creado un archivo [mv-exemple-1.0-SNAPSHOT.jar].
3.1.4. El repositorio local de Maven
Ya mencionamos que Maven descarga las dependencias necesarias para el proyecto y las almacena localmente. Podemos explorar este repositorio local:
 |
- en [1], seleccionamos la opción [Window / Other / Maven Repository Browser],
- en [2], se abre una pestaña [Maven Repositories],
- en [3], contiene dos ramas: una para el repositorio local y otra para el repositorio central. Este último es gigantesco. Para visualizar su contenido, hay que actualizar su índice [4]. Esta actualización dura varias decenas de minutos.
 |
- en [5], las bibliotecas del repositorio local,
- en [6], encontramos una rama [istia.st] que corresponde a [groupId] de nuestro proyecto,
- en [7], se accede a las propiedades del repositorio local,
- en [8], tenemos la ruta del repositorio local. Es útil conocerla porque, en ocasiones (aunque es poco frecuente), Maven ya no utiliza la última versión del proyecto. Hacemos modificaciones y notamos que no se tienen en cuenta. Entonces podemos eliminar manualmente la rama del repositorio local correspondiente a nuestro [groupId]. Esto obliga a Maven a recrear la rama a partir de la última versión del proyecto.
3.1.5. Buscar un artefacto con Maven
Ahora aprendamos a buscar un artefacto con Maven. Comencemos con la lista de dependencias actuales del archivo [pom.xml]:
<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>istia.st</groupId>
<artifactId>mv-exemple</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mv-exemple</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Las líneas 17 a 23 definen las dependencias que vamos a modificar para utilizar las bibliotecas en su versión más reciente.
 |
En primer lugar, eliminamos las dependencias actuales de [1]. A continuación, se modifica el archivo [pom.xml]:
<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>istia.st</groupId>
<artifactId>mv-exemple</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mv-exemple</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies></dependencies>
</project>
En la línea 17, la dependencia eliminada ya no aparece en [pom.xml]. Ahora, busquémosla en los repositorios de Maven.
 |
- En [1], se agrega una dependencia al proyecto,
- en [2], debemos especificar información sobre el artefacto buscado (groupId, artifactId, versión, empaquetado (Tipo) y alcance). Comenzamos por especificar el [groupId] [3],
- en [4], escribimos [espace] para que se muestre la lista de artefactos posibles. Aquí aparecen [junit] y [jnit-dep]. Seleccionamos [junit],
- en [5], siguiendo el mismo procedimiento, elegimos la versión más reciente. El tipo de empaquetado es jar,
- y [6]; elegimos el ámbito de prueba para indicar que la dependencia solo es necesaria para las pruebas.
 |
En [6], las dependencias agregadas aparecen en el proyecto. El archivo [pom.xml] refleja estos cambios:
<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>istia.st</groupId>
<artifactId>mv-exemple</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mv-exemple</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
<type>jar</type>
</dependency>
</dependencies>
</project>
Cabe señalar que el archivo [pom.xml] no menciona la dependencia [hamcrest-core-1.1] que vemos en [6]. Esto se debe a que es una dependencia de JUnit 4.10 y no del proyecto en sí. Esto se indica con un ícono diferente en la rama [Dependencies]. Se descargó automáticamente.
Supongamos ahora que no conocemos el [groupId] del artefacto que deseamos. Por ejemplo, queremos usar Hibernate como ORM (mapeador objeto-relacional) y eso es todo lo que sabemos. Entonces podemos ir al sitio [http://mvnrepository.com/]:
 |
En [1], podemos escribir palabras clave. Escribamos hibernate y realicemos la búsqueda.
 |
- En [2], elijamos el [groupId], el org.hibernate y el [artifactId], el hibernate-core,
- en [3], elijamos la versión 4.1.2-Final,
- en [4], obtenemos el código de Maven para pegar en el archivo [pom.xml]. Lo hacemos.
<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>istia.st</groupId>
<artifactId>mv-exemple</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mv-exemple</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.1.2.Final</version>
</dependency>
</dependencies>
</project>
Guardamos el archivo [pom.xml]. A continuación, Maven comienza a descargar las nuevas dependencias. El proyecto evoluciona de la siguiente manera:
 |
- a [5], la dependencia [hibernate-core-4.1.2-Final]. En el repositorio donde se encontró, este [artifactId] también está descrito por un archivo [pom.xml]. Este archivo se leyó y Maven descubrió que el [artifactId] tenía dependencias. También las descarga. Hará lo mismo con cada [artifactId] descargado. Al final, en el archivo [6] encontramos dependencias que no habíamos solicitado directamente. Estas se identifican con un ícono diferente al del archivo principal [artifactId].
En este documento, utilizamos Maven principalmente por esta característica. Esto nos evita tener que conocer todas las dependencias de una biblioteca que queremos utilizar. Dejamos que Maven se encargue de gestionarlas. Además, al compartir un archivo [pom.xml] entre desarrolladores, nos aseguramos de que cada desarrollador utilice efectivamente las mismas bibliotecas.
En los ejemplos que siguen, nos limitaremos a proporcionar el archivo [pom.xml] utilizado. El lector solo tendrá que utilizarlo para encontrarse en las mismas condiciones que el documento. Además, los proyectos de Maven son compatibles con los principales entornos de desarrollo de Java (Eclipse, NetBeans, IntelliJ, JDeveloper). De este modo, el lector podrá utilizar su IDE favorito para probar los ejemplos.