Arquetipos de maven:
cómo crear, distribuir y generar
proyectos con JSF e ICEfaces, JBoss y EJB3

1. Arquetipos de maven: cómo crear, distribuir y
   generar
   proyectos con JSF e ICEfaces, JBoss y EJB3
   1. Introducción
   2. Arquetipos de
      maven ¿qué y para qué?
   3. Ciclo
      de
      vida de un arquetipo de maven
   4. 
      Estructura básica de un arquetipo de maven
   5. Crear
      un proyecto básico de maven a partir del arquetipo
      maven-archetype-archetype
      1. Crear
         la
         estructura del arquetipo
      2. 
         Compilar el arquetipo
      3. Publicar
         el artefacto en un
         repositorio
      4. Generar proyectos
         a partir del arquetipo
   6. 
      Crear un
      proyecto J2EE a partir del arquetipo maven-archetype-j2ee-simple
   7. Crear un arquetipo basado en JSF + ICEfaces,
      JBoss y EJB3
      1. Estructura del
         proyecto
      2. Publicar el arquetipo
         en un repositorio
      3. Generar
         proyectos
         a partir del arquetipo
   8. 
      Conclusión

Introducción

Si eres lector habitual de nuestros tutoriales, o has echado un
vistazo a aquellos en los que se desarrollan aplicaciones JEE, sabrás
que en Autentia apostamos por maven como herramienta para la
gestión de nuestros proyectos.

Este tutorial trata en
detalle los arquetipos de maven y desarrolla un ejemplo completo: un
arquetipo que ofrezca las bases para desarrollar con Java Server Faces
(JSF) e ICEFaces, JBoss y EJB3.

Para comprender mejor
utilidad de los arquetipos, voy a tomar el estupendo tutorial de
nuestro gran Paco: Icefaces, JBoss, Maven2 y EJB3 (partes 1, 2, 3, 4 y 5) y voy a hacer el arquetipo multimódulo
(‘esqueleto configurado’) sobre el que desarrollar la aplicación JEE
que ahí se explica.

En este enlace: arquetipoMavenAutentia.zip
dispones del código fuente del tutorial.

Arquetipos de
maven ¿qué y para qué?

En esencia, un arquetipo es un
patrón o modelo original sobre el que pueden desarrollar todas aquellas
cosas que son de un mismo tipo. Puede decirse que son plantillas,
parametrizadas o configuradas para utilizar determinadas tecnologías,
que los programadores utilizan como base para escribir y organizar el
código de la aplicación.

Que todos los proyectos que
involucren ciertas tecnologías partan de una base (arquetipo, plantilla
o esqueleto configurado) común, tiene ventajas evidentes:

• Consistencia
  entre distintos desarrollos cuyo punto en común son las mismas
  tecnologías o el entorno configurado sobre las que serán deplegados y
  ejecutados
• Reutilización y composición de unos arquetipos
  como suma de otros.
• Estandarización de los proyectos dentro
  de una organización. Los arquetipos son compartidos desde uno o más
  repositorios y todos los empleados tienen acceso a ellos.
• Se
  evitan tiempos muertos en el comienzo de la implementación al
  disponerse de un entorno ya correctamente configurado.
• La
  estructura del proyecto facilita las tareas de desarrollar, distribuir,
  portar y desplegar, al equipo de programadores.

Al igual
que los patrones de diseño nos evitan el tener que reinventar la rueda
ante situaciones con características similares, los arquetipos nos
evitan el tener que configurar las bases de un proyecto (librerías,
dependencias, configuraciones) cuando se basan en tecnologías comunes o
están orientados a un determinado entorno de despliegue.

Ciclo de
vida de un arquetipo de maven

Podemos representar un conjunto de pasos estándar en la creación y uso de un arquetipo:

Ciclo de vida
habitual de un arquetipo de maven

Al respecto de este ciclo de vida, aclarar que si se realiza en un
mismo equipo, el tercer paso (mvn install:install) es opcional.

En siguientes secciones recorreremos el
ciclo de vida de tres arquetipos distintos a modo de ejemplo

Estructura básica de un arquetipo de maven

Todo arquetipo
se compone de:

• [1] Un pom.xml a nivel raíz del
  arquetipo, necesario para la construcción del mismo
• [2] Los
  ficheros que compondrán el cuerpo del arquetipo. Se sitúan bajo
  src/main/resources/archetype-resources/
• [3] Los pom.xml de
  los módulos que componen el prototipo del arquetipo
• [4] El
  descriptor de arquetipos archetype.xml, que se sitúa en el directorio
  src/main/resources/META-INF y que indica al mecanismo de generación de
  arquetipos todo el contenido del que estamos definiendo.

Podemos ilustrarlo con la sigueinte estructura de un arquetipo de maven
básico:

Arquetipo básico de maven: maven-archetype-archetype

Crear
un proyecto básico de maven a partir del arquetipo
maven-archetype-archetype

Maven provee un arquetipo básico;
vamos a utilizarlo para completar un ciclo de vida

Crear la
estructura del arquetipo

Para crear un arquetipo básico
para desarrollar un proyecto con maven, disponemos del siguiente
comando:

• mvn
  archetype:create -DgroupId=[your project’s group id] -DartifactId=[your
  project’s artifact id] -DarchetypeArtifactId=maven-archetype-archetype

Creamos un proyecto a partir de un arquetipo básico de
maven:

mvn archetype:create
-DgroupId=com.autentia -DartifactId=proyecto-basico
-DarchetypeArtifactId=maven-archetype-archetype

Y
obtendremos una estructura de directorios así:

Arquetipo básico de maven: maven-archetype-archetype

La versión por defecto que genera es la
1.0-SNAPSHOT. Puede añadirse -Dversion=<version> para indicar la
versión deseada. En nuestor caso, 1.0-SNAPSHOT nos sirve.

Las trazas de la generación mostrará el
mensaje:

[WARNING] This goal is deprecated. Please use mvn archetype:generate
instead

Haciéndolo de este modo
podremos confrmar y/o introducir el groupId, version y artifactId de
manera interactiva según se hayan introducido como parámetros al
comando mvn archetype:generate.

NOTA:

En este punto debemos hacer
un inciso. Los arquetipos generados con el plugin
maven-archetype-archetype contienen un bug (reportado en https://issues.apache.org/jira/browse/ARCHETYPE-96),
y debemos corregir lo siguiente:

• En src/main/resouces/archetype-resources/src/main/java/App.java
  y src/main/resouces/archetype-resources/src/test/java/AppTest.java,
  sustituir: package $com.autentia;
  por: package
  $package;
• En
  src/main/resouces/archetype-resources/pom.xml cambiar:

  <groupId>$com.autentia</groupId>
  <artifactId>$proyecto-basico</artifactId>
  <version>$1.0-SNAPSHOT</version>
  

  por

  <groupId>$groupId</groupId>
  <artifactId>$artifactId</artifactId>
  <version>$version</version>      
  

Compilar el arquetipo

Nos situamos en la
carpeta proyecto-basico y ejecutamos:

mvn install

Habremos generado el artefacto
proyecto-basico-1.0-SNAPSHOT.jar en el directorio /target e instalado
en el repositorio local. Vamos a instalarlo en un repositorio remoto
para compartirlo públicamente.

Publicar el artefacto en un
repositorio

Nos situamos en el servidor del repositorio
remoto e instalamos el artefacto proyecto-basico-1.0-SNAPSHOT.jar:

mvn install:install-file
-Dfile=proyecto-basico-1.0-SNAPSHOT.jar -DgroupId=com.autentia
-DartifactId=proyecto-basico -Dversion=1.0-SNAPSHOT -Dpackaging=jar
-DgeneratePom=true -DcreateChecksum=true

Generar proyectos
a partir del arquetipo

Desde un equipo de desarrollo con el
.m2/settings.xml correctamente configurado para acceder al repositorio
remoto, nos situamos en el directorio deseado y ejecutamos el comando:

mvn archetype:create
-DarchetypeGroupId=com.autentia -DarchetypeArtifactId=proyecto-basico
-DarchetypeVersion=1.0-SNAPSHOT -DgroupId=com.miempresa.miproyecto
-DartifactId=miProyectoBasico

La estructura del proyecto que
ha generado a partir del arquetipo es la siguiente:

Estructura del proyecto básico generado a partir del arquetipo

miProyectoBasico sienta las bases para
desarrollar una aplicacion Java Estándar gestionada por maven en su
desarrollo. En este mismo punto, sólo con las clases App.java y su test
unitario AppTest.java, podríamos hacer un mvn install y generaríamos el
artefacto miProyectoBasico-1.0-SNAPSHOT.jar.
Pero esto no es muy interesante realmente….

Crear un
proyecto J2EE a partir del arquetipo maven-archetype-j2ee-simple

Si queremos crear una aplicación de tipo J2EE, dejemos que maven
nos cree la estructura y configuración necesarios, y comenzamos a
programar en un santiamén. Utilizamos un arquetipo J2EE de maven:
maven-archetype-j2ee-simple.

mvn
archetype:create -DgroupId=com.autentia
-DartifactId=proyecto-j2ee-basico
-DarchetypeArtifactId=maven-archetype-j2ee-simple

Y
obtendremos un entorno con las dependencias resueltas (siempre podemos
modificar algún pom.xml y ajustarlo a nuestras necesidades) para usar
ejb, servlets, javadoc, etc. Vemos que ha creado un proyecto de maven
multimódulo:

Proyecto J2EE básico de maven generado gracias al arquetipo
maven-archetype-j2ee-simple

Este
ha sido un ejemplo de un arquetipo ya preparado para ser usado.

Crear un arquetipo
basado en JSF + ICEfaces, JBoss y EJB3

Comencemos con el ejercicio má sinteresante. Como queremos crear el
arquetipo para la aplicación de Paco, vamos a descargarnos su código y
examinar la estructura de módulos:

C:.
+---Modelo
|   +---src
|       \---main
|           \---java
|               \---META-INF
\---Web
    +---src
        \---main
            +---java
            +---resources
            \---webapp
                +---META-INF
                +---WEB-INF
                |   \---lib
                \---xmlhttp
                    \---css
                        +---royale
                        |   \---css-images
                        \---xp
                            \---css-images
    

Asimismo revisamos los pom.xml, los ficheros de propiedades,
configuración, etc. Nuestro arquetipo no debe contener el código de la
aplicación de la biblioteca. Debe contener sólo la estructura de
directorios, ficheros de propiedades y configuración genéricos para el
servidor, los pom.xml que resuelvan adecuadamente las tecnologías y
adaptados para formar parte de un arquetipo etc. Lo mostramos a
continuación

Estructura del proyecto

Por
comodidad utilizo Eclipse para crear los directorios y añadir el poco
código que vamos a necesitar. Muestro en imágenes la construcción del
arquetipo paso a paso.

Creamos un proyecto de tipo General
(ni siquiera de java), lo llamamos maven-archetype-IJE-1.0 (IJE = Icefaces JBoss EJB) y creamos la siguiente
estructura de directorios y ficheros (éstos de momento vacíos):

Estructura
inicial del arquetipo con los dos módulos web y core

Estructura del módulo core; contendrá el modelo

Estructura del módulo web

Vamos a
dar cuerpo a los archivos que hemos creado en blanco:

• Los
  ficheros royale.css, xp.css y xp-portlet.css serán los mismos que los
  que encontramos en los fuentes del tutorial de Paco
• Igualmente
  copiaremos las imágenes de css/royale/css-images y css/xp/css-images de
  los fuentes de su tutorial
• Ídem de los
  commons-logging.properties y log4j.properties de ambos módulos
  core-module y web-module
• database-script.sql podemos
  dejarlo en blanco

El resto de ficheros son:

App.java:

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
    }
}    

AppTest.java:

   
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 );
    }
}

AutentiaIJE-ds.xml (un datasource genérico con MySQL):

<?xml version="1.0" encoding="UTF-8"?>

<datasources>
 <local-tx-datasource>
   <jndi-name>autentiaIJEDS</jndi-name>
   <connection-url>jdbc:mysql://localhost:3306/esquemabbdd</connection-url>
   <driver-class>com.mysql.jdbc.Driver</driver-class>

   <user-name>xxxxx</user-name>
   <password>xxxx</password>
 </local-tx-datasource>
</datasources>

persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

        <persistence-unit name="xxxxxxx" transaction-type="JTA">

                <!-- Defines the JPA provider. For JBoss you should use Hibernate. -->
                <provider>org.hibernate.ejb.HibernatePersistence</provider>

                <!-- Defines the datasource to be used by the persistente unit -->
                <jta-data-source>java:/autentiaIJE</jta-data-source>

                <!-- As Hibernte is your JPA provider, you can set some Hibernate properties -->
                <properties>
                        <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect" />
                </properties>
        </persistence-unit>
</persistence>

core-module/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/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
    <parent>
      <groupId>${groupId}</groupId>
      <artifactId>${artifactId}</artifactId>
      <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>${groupId}</groupId>
    <artifactId>${artifactId}-modelo</artifactId>
    <version>${pom.parent.version}</version>
    <packaging>ejb</packaging>
        <name>Modulo Modelo</name>
        <description>
                Modulo encargado del modelo de negocio y de la persistencia de la aplicacion.
                Desarrollado con EJB 3.0.
        </description>    
        <build>
                <plugins>
                        <plugin>
                                <artifactId>maven-ejb-plugin</artifactId>
                                <configuration>
                                        <ejbVersion>3.0</ejbVersion>
                                        <archive>
                                                <manifest>
                                                        <addClasspath>true</addClasspath>
                                                </manifest>
                                        </archive>
                                </configuration>
                        </plugin>
                </plugins>
        </build>  
        <dependencies>
                        <dependency>
                        <groupId>javax.persistence</groupId>
                        <artifactId>persistence-api</artifactId>
                        <version>1.0</version>
                        <scope>provided</scope>
                </dependency>             
                <dependency>
                        <groupId>javax.transaction</groupId>
                        <artifactId>jta</artifactId>
                        <version>1.0.1B</version>
                        <scope>provided</scope>                     
                </dependency>             
                <dependency>
                        <groupId>javax.activation</groupId>
                        <artifactId>activation</artifactId>
                        <version>1.1</version>
                        <scope>compile</scope>
                </dependency>             
                <dependency>
                        <groupId>javax.ejb</groupId>
                        <artifactId>ejb-api</artifactId>
                        <version>3.0</version>
                        <scope>provided</scope>
                </dependency>             
                <dependency>
                        <groupId>jboss</groupId>
                        <artifactId>jboss-ejb-api</artifactId>
                        <version>4.2.0.GA</version>
                        <scope>provided</scope>
                </dependency>             
        </dependencies>
</project>

web-module/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/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
      <groupId>${groupId}</groupId>
      <artifactId>${artifactId}</artifactId>
      <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>${groupId}</groupId>
    <artifactId>${artifactId}-web</artifactId>
    <packaging>war</packaging>
    <version>${pom.parent.version}</version>
        <name>Modulo Web</name>
        <description>
                Modulo encargado de la vista y el control. JSF RI e Icefaces
        </description>  
  <dependencies>                
      <!-- Core J2EE -->
      <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>2.5</version>
                <scope>provided</scope>
        </dependency>
        <dependency>
        <groupId>javax.servlet.jsp</groupId>
                <artifactId>jsp-api</artifactId>
        <version>2.1</version>
        <scope>provided</scope>
        </dependency>                
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.1.2</version>
    </dependency>                
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>el-api</artifactId>
        <version>1.0</version>
        <scope>provided</scope>
    </dependency>
    <!-- JSF -->
    <dependency>
        <groupId>javax.faces</groupId>
        <artifactId>jsf-api</artifactId>
        <version>1.2_04-p01</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.faces</groupId>
        <artifactId>jsf-impl</artifactId>
        <version>1.2_04-p01</version>
        <scope>provided</scope>
    </dependency>
    <!-- ICEFaces -->                
    <dependency>
                <groupId>org.icefaces</groupId>
                <artifactId>icefaces</artifactId>
                <version>1.6.1</version>
        </dependency>
        <dependency>
                <groupId>org.icefaces</groupId>
                <artifactId>icefaces-comps</artifactId>
                <version>1.6.1</version>
        </dependency>
        <dependency>
                <groupId>org.icefaces</groupId>
                <artifactId>icefaces-facelets</artifactId>
                <version>1.6.1</version>
        </dependency>
    <dependency>
        <groupId>backport-util-concurrent</groupId>
        <artifactId>backport-util-concurrent</artifactId>
        <version>3.1</version>
    </dependency> 
  </dependencies>  
</project>

/src/main/resources/archetype-resources/pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<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>${groupId}</groupId>
  <artifactId>${artifactId}</artifactId>
  <packaging>pom</packaging>
  <name>Modulo padre de una aplicacion JEE con ICEFACES, JBOSS y EJB3</name>
  <version>1.0-SNAPSHOT</version>
	<description>
		Este proyecto es el padre de todas los modulos. Dirige la compilacion y
		configuracion comun.
	</description>
	<modules>		
		<module>web-module</module>
		<module>core-module</module>		
	</modules>	
	
    <build>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
               <source>1.5</source>
               <target>1.5</target>
               <encoding>UTF-8</encoding>
             </configuration>
         </plugin>
       </plugins>
    </build>
    
	 <repositories>
		<repository>
			<id>java-net</id>
			<name>java-net</name>
			<url>http://download.java.net/maven/2</url>
		</repository>
		<repository>
			<id>java.net</id>
			<url>http://download.java.net/maven/1</url>
			<layout>legacy</layout>
		</repository>
		<repository>
			<id>jboss</id>
			<url>http://repository.jboss.com/maven2/</url>
		</repository>		
	</repositories>	
	<dependencies>                
      <!-- Comunes a los modulos -->
       <dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
       <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.14</version>
          <scope>provided</scope>
       </dependency>
       <dependency>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
          <version>1.1</version>
       </dependency>
   </dependencies>
   


</project>

pom.xml a nivel raíz:

<?xml version="1.0" encoding="UTF-8"?>
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.autentia.maven</groupId>
  <artifactId>maven-archetype-IJE</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
</project>

archetype.xml (aparece truncado dada su longitud, véase en los
fuentes adjuntos a este tutorial):

<archetype>
        <id>autentia-IJE-archetype</id>
        <sources>
        </sources>

        <resources>

                <!-- Model resources -->
                <resource>core-module/src/main/java/App.java</resource>
                <resource>core-module/src/test/java/AppTest.java</resource>
                <resource>core-module/doc/autentiaIJE-ds.xml</resource>
                <resource>core-module/doc/sql/database-script.sql</resource>
                <resource>core-module/resources/commons-logging.properties</resource>
                <resource>core-module/resources/log4j.properties</resource>
                <resource>core-module/src/main/java/META-INF/persistence.xml</resource>
                <resource>core-module/pom.xml</resource>
                



                <!-- Web resources -->
                <resource>web-module/resources/commons-logging.properties</resource>
                <resource>web-module/resources/log4j.properties</resource>
                <resource>web-module/src/main/webapp/WEB-INF/faces-config.xml</resource>
                <resource>web-module/src/main/webapp/WEB-INF/faces-config.xml</resource>
                <resource>web-module/src/main/webapp/WEB-INF/web.xml</resource>
                <resource>web-module/src/main/webapp/xmlhttp/css/royale/royale.css</resource>
                <resource>web-module/src/main/webapp/xmlhttp/css/royale/css-images/add.gif</resource>
                ...
                <resource>web-module/src/main/webapp/xmlhttp/css/royale/css-images/window_top.gif</resource>
                <resource>web-module/src/main/webapp/xmlhttp/css/xp/xp.css</resource>
                <resource>web-module/src/main/webapp/xmlhttp/css/xp/xp-portlet.css</resource>
                <resource>web-module/src/main/webapp/xmlhttp/css/xp/css-images/add.gif</resource>
                ...
                <resource>web-module/src/main/webapp/xmlhttp/css/xp/css-images/window_top.gif</resource>
                <resource>web-module/pom.xml</resource>


                <!-- Parent resources -->
                <resource>pom.xml</resource>
                <resource>Readme.txt</resource>
                
        </resources>
        <testSources></testSources>
</archetype>
    

Publicar el
arquetipo en un repositorio

Ejecutamos mvn
install desde línea de comandos para generar el jar con el arquetipo:

mvn install

Habrá instalado el
artefacto generado: maven-archetype-IJE-1.0-SNAPSHOT.jar en nuestro
repositorio local. Como queremos compartirlo con toda la organización,
lo instalaremos en un repositorio de maven a tal efecto en nuestra
intranet. Por ejemplo ejecutamos el siguiente comando en el servidor de
maven:

mvn install:install-file -Dfile=maven-archetype-IJE-1.0-SNAPSHOT.jar -DgroupId=com.autentia -DartifactId=maven-archetype-IJE -Dversion=1.0-SNAPSHOT -Dpackaging=jar -DgeneratePom=true -DcreateChecksum=true

Generar proyectos
a partir del arquetipo

Ahora podremos generar proyectos de
un mismo tipo como churros. El arquertipo estará disponible en
un repositorio remoto, a si que completamos el .m2/settings.xml de
nuestro equipo de desarrollo con la URL del servidor del repositorio (y
las posibles credenciales):

.m2/settings.xml:

...
<profiles>
   <profile>
      <id>MiRepositorioDeAutentia</id>
      <repositories>
        <repository>

           <id>autentiarepo</id>
           <url>http://192.168.168.31:8098/mvn-repo</url>
        </repository>
      </repositories>
    </profile>

</profiles>
...
<servers>
   <server>
      <username>igpueblaxxxx</username>
      <password>yyyyyy</password>

      <id>autentiarepo</id>
   </server>
</servers>
...
<activeProfiles>
  <activeProfile>MiRepositorioDeAutentia</activeProfile>

</activeProfiles>

Ahora podremos ejecutar el comando para generar el
esqueleto del proyecto de una biblioteca basado en el arquetipo
maven-archetype-IJE. Nos situamos ahí donde queramos crear el proyecto
y ejecutamos:

mvn archetype:create
-DarchetypeGroupId=com.autentia
-DarchetypeArtifactId=maven-archetype-IJE
-DarchetypeVersion=1.0-SNAPSHOT -DgroupId=com.autentia.biblioteca
-DartifactId=biblioteca-parent

Veremos que se ha conectado
al repositorio por HTTP, ha descargado el artefacto a nuestro
repositorio local y ha creado la estructura del proyecto en
biblioteca-parent:

Quedando por tanto la estructura
(no se muestran los ficheros):

Estructura
generada por el arquetipo con el comando mvn archetype:create

Nuestro arquetipo está preparado para crear con toda normalidad la
aplicación que propone Paco en su tutorial.

Conclusión

Hemos presentado otra de las aportaciones de maven al desarrollo de
proyectos. ¿Merece la pena hacer algo tan laborioso? Pues depende de la
situación y el contexto en el que te muevas, pero cuando estamos
hablando de un equipo de programadores pronto te darás cuenta que
gestionar el ciclo de desarrollo con maven y disponer de una estructura
de desarrollo estándar, portable y fácilmente mantenible, hace con
mucho que merezca la pena invertir un tiempo inicial en tener un
entorno basado en maven; a la larga, compensa con creces…

… ¡te lo decimos desde Autentia por propia experiencia!

Si te
gusta lo que ves o piensas que puede ser útil para los desarrollos de
tu empresa o departamento, recuerda que desde Autentia podemos
ayudarte.