Entra en Adictos a través de

• Deseo registrarme
• Olvidé mi contraseña

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 http://jira.codehaus.org/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:

C:\Tutoriales\tests>mvn archetype:create -DarchetypeGroupId=com.autentia -DarchetypeArtifactId=maven-archetype-IJE -DarchetypeVersion=1.0-SNAPSHOT -DgroupId=com.autentia.biblioteca -DartifactId=biblioteca-parent [INFO] Scanning for projects... [INFO] Searching repository for plugin with prefix: 'archetype'. [INFO] ------------------------------------------------------------------------ [INFO] Building Maven Default Project [INFO] task-segment: [archetype:create] (aggregator-style) [INFO] ------------------------------------------------------------------------ [INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'. [INFO] Setting property: velocimacro.messages.on => 'false'. [INFO] Setting property: resource.loader => 'classpath'. [INFO] Setting property: resource.manager.logwhenfound => 'false'. [INFO] [archetype:create] [WARNING] This goal is deprecated. Please use mvn archetype:generate instead [INFO] Defaulting package to group ID: com.autentia.biblioteca [INFO] snapshot com.autentia:maven-archetype-IJE:1.0-SNAPSHOT: checking for updates from autentiarepo Downloading: http://192.168.168.31:8098/mvn-repo/com/autentia/maven-archetype-IJE/1.0-SNAPSHOT/maven-archetype-IJE-1.0-SNAPSHOT.jar 154K downloaded [INFO] ---------------------------------------------------------------------------- [INFO] Using following parameters for creating OldArchetype: maven-archetype-IJE:1.0-SNAPSHOT [INFO] ---------------------------------------------------------------------------- [INFO] Parameter: groupId, Value: com.autentia.biblioteca [INFO] Parameter: packageName, Value: com.autentia.biblioteca [INFO] Parameter: basedir, Value: C:\Tutoriales\tests\ [INFO] Parameter: package, Value: com.autentia.biblioteca [INFO] Parameter: version, Value: 1.0-SNAPSHOT [INFO] Parameter: artifactId, Value: biblioteca-parent [INFO] ********************* End of debug info from resources from generated POM *********************** [INFO] OldArchetype created in dir: C:\Tutoriales\tests\\biblioteca-parent [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESSFUL [INFO] ------------------------------------------------------------------------ [INFO] Total time: 8 seconds [INFO] Finished at: Mon Jun 09 08:55:20 CEST 2008 [INFO] Final Memory: 7M/14M [INFO] ------------------------------------------------------------------------

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.

Esta obra está licenciada bajo licencia Creative Commons de Reconocimiento-No comercial-Sin obras derivadas 2.5