De un traductor: Hace unos años, me propuse el objetivo de conocer rápidamente, pero con bastante rigor, un marco tan utilizado como Apache Maven . Casi de inmediato, logré encontrar la literatura adecuada, pero me sorprendió un poco el hecho de que todos los materiales complejos estaban exclusivamente en inglés, mientras que en ruso había muchos artículos dispersos, pero no pude encontrar un libro completo que pudiera leerse de principio a fin. triunfado Como resultado, para leer, elegí un pequeño libro, Introducción a Maven, escrito por Balaji Varnasi y Sudha Belida y publicado por Apress en 2014. A medida que se resolvieron todas las tareas, gradualmente di a luz una traducción de esta publicación, que, aunque ha estado en mi escritorio durante un par de años, aún puede ser útil para la comunidad.
Aquí doy una traducción de solo uno de los capítulos de este libro, pero todo se puede descargar aquí desde estos enlaces en inglés o en ruso (PDF).
Capítulo 6: Arquetipos de Maven
Hasta este punto, creó el proyecto Maven manualmente, creando carpetas y archivos
pom.xml desde cero. Esto puede ser tedioso, especialmente si a menudo tiene que crear proyectos. Para resolver este problema, Maven proporciona arquetipos.
Los arquetipos de Maven son proyectos predefinidos que permiten a los usuarios crear fácilmente nuevos proyectos.
Los arquetipos de Maven también proporcionan una base conveniente para compartir experiencias y garantizar la coherencia de la estructura de directorios estándar de Maven. Por ejemplo, una empresa puede crear un arquetipo con una hoja de estilo en cascada (
CSS ), bibliotecas aprobadas de
JavaScript y componentes reutilizables. Los desarrolladores que usan estos arquetipos para crear proyectos seguirán automáticamente los estándares de la compañía.
Arquetipos incorporados
Fuera de la caja, Maven ofrece a los desarrolladores cientos de arquetipos. Además, hay muchos proyectos de código abierto que proporcionan arquetipos adicionales que puede descargar y usar. Maven también proporciona arquetipos de plug-in con objetivos para crear arquetipos y generar proyectos a partir de arquetipos.
El complemento arquetipo tiene un objetivo de
generación que le permite ver y seleccionar el arquetipo requerido.
El Listado 6-1 muestra los resultados de ejecutar el objetivo de generación desde la línea de comando. Como puede ver, se dieron 491 arquetipos para elegir
(en 2018 ya había más de 2 mil, aprox. Transl.) . El uso de varios de ellos se discute en este capítulo.
Listado 6-1. El complemento arquetipo de Maven genera una llamada de destino$mvn archetype:generate [INFO] Scanning for projects... [INFO] [INFO] ----------------------------------------------------------------------- [INFO] Building Maven Stub Project (No POM) 1 [INFO] ----------------------------------------------------------------------- [INFO] [INFO] >>> maven-archetype-plugin:2.2:generate (default-cli) @ standalone- pom >>> [INFO] [INFO] <<< maven-archetype-plugin:2.2:generate (default-cli) @ standalone- pom <<< [INFO] [INFO] --- maven-archetype-plugin:2.2:generate (default-cli) @ standalone- pom [INFO] Generating project in Interactive mode [INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0) ........................... ........................... 1176: remote -> ru.yandex.qatools.camelot:camelot-plugin (-) 1177: remote -> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-) 1178: remote -> sk.seges.sesam:sesam-annotation-archetype (-) 1179: remote -> tk.skuro:clojure-maven-archetype (A simple Maven archetype for Clojure) 1180: remote -> tr.com .lucidcode:kite-archetype (A Maven Archetype that allows users to create a Fresh Kite project) 1181: remote -> uk.ac.rdg.resc:edal-ncwms-based-webapp (-) 1182: local -> com.inflinx.book.ldap:practical-ldap-empty-archetype (-) 1183: local -> com.inflinx.book.ldap:practical-ldap-archetype (-) Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 491:
Creación de proyectos web.
Maven proporciona el
arquetipo maven-archetype-webapp para generar una aplicación web.
Creemos una aplicación de este tipo llamando al siguiente comando en la
carpeta C: \ apress \ gswm-book \ chapter6 :
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp
Este comando se ejecuta de forma interactiva. Para preguntas entrantes, ingrese la siguiente información:
Define value for property 'groupId': : com.apress.gswmbook Define value for property 'artifactId': : gswm-web Define value for property 'version': 1.0-SNAPSHOT: : <<Hit Enter>> Define value for property 'package': com.apress.gswmbook: : war Confirm the properties configuration: groupId: com.apress.gswmbook artifactId: gswm-web version: 1.0-SNAPSHOT package: war Y: <<Hit Enter>>
La estructura de carpetas generada debería verse como la que se muestra en la
Figura 6-1 :
Figura 6-1. Estructura del proyecto web Maven
El archivo
pom.xml es mínimo y contiene una sola dependencia:
JUnit . Maven puede simplificar el lanzamiento de su aplicación web utilizando servidores web integrados como
Tomcat o
Jetty .
El Listado 6-2 muestra el archivo
pom.xml modificado con el complemento
Tomcat agregado.
Listado 6-2. Archivo pom.xml modificado con el complemento Tomcat incorporado <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>com.apress.gswmbook</groupId> <artifactId>gswm-web</artifactId> <packaging>war</packaging> <version>1.0-SNAPSHOT</version> <name>gswm-web Maven Webapp</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> <build> <finalName>gswm-web</finalName> <plugins> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> </plugin> </plugins> </build> </project>
Para ejecutar esta aplicación web en el servidor
Tomcat , llame al siguiente comando en el directorio raíz del proyecto:
mvn tomcat7:run
Verá un proyecto detallado y una salida similar a la que se muestra en el
Listado 6-3 .
Listado 6-3. Salida de comando de ejecución de Tomcat Oct 11, 2014 12:08:43 PM org.apache.catalina.core.StandardService startInternal INFO: Starting service Tomcat Oct 11, 2014 12:08:43 PM org.apache.catalina.core.StandardEngine startInternal INFO: Starting Servlet Engine: Apache Tomcat/7.0.47 Oct 11, 2014 12:08:45 PM org.apache.catalina.util.SessionIdGenerator createSecureRandom INFO: Creation of SecureRandom instance for session ID generation using [SHA1PRNG] took [334] milliseconds. Oct 11, 2014 12:08:45 PM org.apache.coyote.AbstractProtocol start INFO: Starting ProtocolHandler ["http-bio-8080"]
Ahora inicie su navegador y vaya a
localhost : 8080 / gswm-web / . Debería ver una página web como la que se muestra en la
Figura 6-2 .
Figura 6-2. Proyecto web que se ejecuta en un navegador
Proyecto multimodular
Los proyectos Java Enterpise Edition (JEE) a menudo se dividen en varios módulos para facilitar el desarrollo y mantenimiento. Cada uno de estos módulos produce artefactos como
Enterprise JavaBeans (EJB) , servicios web, proyectos web y
JAR de clientes. Maven admite el desarrollo de proyectos
JEE tan grandes, lo que le permite alojar múltiples proyectos Maven dentro de otro proyecto Maven. La estructura de dicho proyecto de módulos múltiples se muestra en la
Figura 6-3 . El proyecto padre tiene un archivo
pom.xml y varios proyectos Maven dentro.
Figura 6-3. La estructura de un proyecto de módulos múltiples.
Hasta el final de este capítulo, explicaremos cómo construir un proyecto de varios módulos para una tarea en la que necesita dividir un proyecto grande en una aplicación web (artefacto
WAR ) que proporciona una interfaz de usuario, un proyecto de servicio (artefacto
JAR ) que contiene el código de la capa de servicio y el proyecto
Persistencia que contiene el código de nivel de repositorio.
La Figura 6-4 muestra una representación visual de tal escenario.
Figura 6-4. Proyecto multimodular Maven
Comencemos el proceso creando un proyecto principal. Para hacer esto, ejecute el siguiente comando en el símbolo del sistema en la carpeta C: \ apress \ gswm-book \ chapter6:
mvn archetype:generate -DgroupId=com.apress.gswmbook -DartifactId=gswm-parent -Dversion=1.0.0-SNAPSHOT -DarchetypeGroupId=org.codehaus.mojo.archetypes -DarchetypeArtifactId=pom-root
El arquetipo
pom-root crea la carpeta
gswm-parent y en ella el archivo
pom.xml .
Como se
muestra en el
Listado 6-4 , el archivo
pom.xml generado tiene un contenido mínimo. Observe que el tipo de
pom se especifica en la etiqueta de
empaquetado del proyecto principal.
Listado 6-4. Archivo principal 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>com.apress.gswmbook</groupId> <artifactId>gswm-parent</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>pom</packaging> <name>gswm-parent</name> </project>
Ahora cree un proyecto web ejecutando el siguiente comando en la
carpeta C: \ apress \ gswm-book \ chapter6 \ gswm-parent :
mvn archetype:generate -DgroupId=com.apress.gswmbook -DartifactId=gswm-web -Dversion=1.0.0-SNAPSHOT -Dpackage=war -DarchetypeArtifactId=maven-archetype-webapp
En el proceso de generar este proyecto web, proporcionó a Maven coordenadas tales como
groupId ,
versión , etc., como parámetros pasados al objetivo generador, que creó el proyecto
gswm-web .
El siguiente paso es crear un proyecto de servicio. Desde la
carpeta C: \ apress \ gswm-book \ chapter6 \ gswm-parent, ejecute el siguiente comando:
mvn archetype:generate -DgroupId=com.apress.gswmbook -DartifactId=gswm-service -Dversion=1.0.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Tenga en cuenta que no especificó el parámetro del
paquete , ya que
maven-archetype-quickstart crea un proyecto
JAR predeterminado. También tenga en cuenta el uso del parámetro
interactiveMode . Simplemente le dice a Maven que ejecute el comando sin solicitar al usuario ninguna información.
Similar al paso anterior, cree el siguiente proyecto Java
gswm-repository ejecutando el siguiente comando en la
carpeta C: \ apress \ gswm-book \ chapter6 \ gswm-parent :
mvn archetype:generate -DgroupId=com.apress.gswmbook -DartifactId=gswm-repository -Dversion=1.0.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Ahora que tiene todos los proyectos generados, eche un vistazo al archivo
pom.xml en la carpeta
gswm-parent .
El listado 6-5 muestra su contenido.
Listado 6-5. Archivo pom.xml primario con módulos <?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/xsd/maven 4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.apress.gswmbook</groupId> <artifactId>gswm-parent</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>pom</packaging> <name>gswm-parent</name> <modules> <module>gswm-web</module> <module>gswm-service</module> <module>gswm-repository</module> </modules> </project>
El elemento de
módulos le permite declarar módulos secundarios en un proyecto de varios módulos. A medida que se genera cada módulo, Maven los registra como hijos. Además, modifica los archivos
pom.xml de los módulos mismos, y les agrega información sobre el
pom.xml padre.
El Listado 6-6 muestra el archivo
pom.xml del proyecto
gswm-web , que especifica el elemento
pom padre.
Listado 6-6. Archivo web módulo pom.xml <?xml version="1.0"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.apress.gswmbook</groupId> <artifactId>gswm-parent</artifactId> <version>1.0.0-SNAPSHOT</version> </parent> <groupId>com.apress.gswmbook</groupId> <artifactId>gswm-web</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>war</packaging> <name>gswm-web Maven Webapp</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> <build> <finalName>gswm-web</finalName> </build> </project>
Ahora que toda la infraestructura está instalada, puede ensamblar el próximo proyecto. Simplemente ejecute el comando
mvn package desde la carpeta
gswm-project , como se muestra en el
Listado 6-7 .
Listado 6-7. Comando de paquete Maven lanzado en el directorio del proyecto padre C:\apress\gswm-book\chapter6\gswm-parent>mvn package [INFO] Scanning for projects... [INFO] ------------------------------------------------------------------------ [INFO] Reactor Build Order: [INFO] [INFO] gswm-parent [INFO] gswm-web Maven Webapp [INFO] gswm-service [INFO] gswm-repository [INFO] ------------------------------------------------------------------------ [INFO] Reactor Summary: [INFO] [INFO] gswm-parent ....................................... SUCCESS [0.001s] [INFO] gswm-web Maven Webapp ............................. SUCCESS [1.033s] [INFO] gswm-service ...................................... SUCCESS [0.552s] [INFO] gswm-repository ................................... SUCCESS [0.261s] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 1.949s [INFO] Finished at: Mon Oct 13 23:09:21 MDT 2014 [INFO] Final Memory: 6M/15M [INFO] ------------------------------------------------------------------------
Crear arquetipos
Maven proporciona varias formas de crear un nuevo arquetipo. Aquí usaremos un proyecto existente para esto.
Comencemos creando un proyecto prototipo que se utilizará como base para generar el arquetipo. Este proyecto será compatible con
Servlet 3.0 y contiene un
Servlet de estado que devuelve un código de estado HTTP 200 ("OK" - solicitud exitosa). En lugar de crear un proyecto web desde cero, copie el proyecto
gswm-web generado previamente y cree el
prototipo gswm-web en la
carpeta C: \ apress \ gswm-book \ chapter6 . Realice los siguientes cambios en el proyecto que acaba de copiar:
1. Elimine todos los demás recursos, como archivos específicos del
Entorno de desarrollo integrado (IDE) (
.project ,
.classpath , etc.) que no desea incluir en el arquetipo.
2. Reemplace el contenido del
archivo web.xml de la carpeta
webapp / WEB-INF . Esto configurará la aplicación web para usar
Servlet 3.0 :
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <display-name>Archetype Created Web Application</display-name> </web-app>
3. Agregue la dependencia
Servlet 3.0 al archivo
pom.xml . El contenido actualizado de
pom.xml se muestra en el
Listado 6-8 .
Listado 6-8. Archivo Pom.xml con dependencia de servlet <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>com.apress.gswmbook</groupId> <artifactId>gswm-web</artifactId> <packaging>war</packaging> <version>1.0-SNAPSHOT</version> <name>gswm-web Maven Webapp</name> <url>http://maven.apache.org</url> <dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.0.1</version> <scope>provided</scope> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies> <build> <finalName>gswm-web</finalName> <plugins> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> </plugin> </plugins> </build> </project>
4. Desde desarrollaremos un proyecto web en Java, luego crearemos una carpeta llamada
java en el directorio
src / main . Del mismo modo, cree las carpetas
test / java y
test / resources en el directorio
src .
5. Cree el archivo
AppStatusServlet.java que pertenece al paquete
com.apress.gswmbook.web.servlet en el directorio
src / main / java . El paquete
com.apress.gswmbook.web.servlet se convierte en la estructura de carpetas
com \ apress \ gswmbook \ web \ servlet . El código fuente del archivo
AppStatusServelet.java se muestra en el
Listado 6-9 .
Listado 6-9. Código fuente para la clase Java AppStatusServlet package com.apress.gswmbook.web.servlet; import javax.servlet.annotation.WebServlet; import javax.servlet.*; import javax.servlet.http.*; import java.io.*; @WebServlet("/status") public class AppStatusServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException { PrintWriter writer = response.getWriter(); writer.println("OK"); response.setStatus(response.SC_OK); } }
Un diseño prototipo en estructura será un viaje al que se muestra en la
figura 6-5 .
Fig. 6-5. Proyecto prototipo generado
Usando la línea de comando, vaya a la
carpeta gswm-web-prototype del proyecto desde el siguiente comando:
mvn archetype:create-from-project
Al final del comando, verá el mensaje
Arquetipo creado en target / generate-sources / archetype . El arquetipo generado se encuentra en la
carpeta gswm-web-prototype / target / generate-sources / archetype .
El siguiente paso es transferir el artefacto recién generado a una carpeta gswm-web-archetype separada para configurarlo antes de publicarlo. Para hacer esto, siga estos pasos:
1. Cree la
carpeta gswm-web-archetype en el
directorio C: \ apress \ gswm-book \ chapter6 .
2. Copie los subdirectorios y archivos de la
carpeta C: \ apress \ gswm-book \ chapter6 \ gswm-web-prototype \ target \ generate-sources \ archetype a la carpeta
gswm-web-archetype .
3. Elimine el subdirectorio de
destino de la
carpeta C: \ apress \ gswm-book \ chapter6 \ gswm-web-archetype .
La estructura de carpetas para
gswm-web-archetype debe ser similar a la que se muestra en la
Figura 6-6 .
Fig. 6-6. Estructura del proyecto de arquetipo web
Comencemos el proceso de modificación con el archivo
pom.xml ubicado en la
carpeta gswm-web-archetype \ src \ main \ resources \ archetype-resources . Cambie
finalName en
pom.xml de
gswm-web a $ {artifactId}. Durante el proceso de creación del proyecto, Maven reemplazará la expresión
$ {artifactId} con el valor proporcionado por el usuario.
Cuando se crea un proyecto a partir de un arquetipo, Maven le pide al usuario el nombre del paquete. Maven crea una estructura de carpetas correspondiente al paquete ubicado en el directorio
src / main / java del proyecto creado. Entonces Maven mueve todos los contenidos de la carpeta
archetype-resources / src / main / java archetype a este paquete. Porque Si desea que
AppStatusServlet esté en el
subpaquete web.servlet , cree la carpeta
web / servlet y mueva el
AppStatusServlet allí. La nueva ubicación de
AppStatusServlet.java se muestra en la
Figura 6-7 .
Figura 6-7. AppStatusServlet en el paquete web.servlet
Abra
AppStatusServlet.java y cambie el nombre del
paquete de
package $ {package}; en el
paquete $ {package} .web.servlet;El paso final para crear un arquetipo es ejecutar el siguiente comando desde la línea de comando, ubicada en la carpeta gswm-web-archetype:
mvn clean install
Usando arquetipos
Una vez que se ha instalado el arquetipo, la forma más fácil de crear un proyecto a partir de él es, en la
carpeta C: \ apress \ gswm-book \ chapter6 , ejecutar el siguiente comando:
mvn archetype:generate -DarchetypeCatalog=local
En respuesta a las consultas de Maven, ingrese los valores que se muestran en el
Listado 6-10 , y verá el proyecto creado.
Listado 6-10. Crear un nuevo proyecto usando un arquetipo C:\apress\gswm-book\chapter6>mvn archetype:generate -DarchetypeCatalog=local [INFO] Scanning for projects... [INFO] [INFO] ------------------------------------------------------------------------ [INFO] Building Maven Stub Project (No POM) 1 [INFO] ------------------------------------------------------------------------ [INFO] Generating project in Interactive mode [INFO] No archetype defined. Using maven-archetype-quickstart (org.apache. maven.archetypes:maven-archetype-quickstart:1.0) Choose archetype:1: local -> com.apress.gswmbook:gswm-web-archetype (gswm-web-archetype) Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 1 Define value for property 'groupId': : com.apress.gswmbook Define value for property 'artifactId': : test-project Define value for property 'version': 1.0-SNAPSHOT: : Define value for property 'package': com.apress.gswmbook: : Confirm properties configuration: groupId: com.apress.gswmbook artifactId: test-project version: 1.0-SNAPSHOT package: com.apress.gswmbook Y: : ------------------------------------------------------------------------------ project [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 1:27.635s [INFO] Finished at: Mon Oct 13 23:36:01 MDT 2014 [INFO] Final Memory: 9M/22M [INFO] ------------------------------------------------------------------------
Porque el archivo
pom.xml para
test-project ya contiene el complemento
Tomcat , luego ejecute el
comando mvn tomcat7: run en la carpeta
C: \ apress \ gswmbook \ chapter6 \ test-project para iniciar el
proyecto . Abra un navegador y vaya a
localhost : 8080 / test-project / status . Verá la inscripción
OK , como se muestra en la
Figura 6-8 .
Figura 6-8. Página generada por el proyecto generado
Resumen
Los arquetipos de Maven son trozos de proyecto que le permiten lanzar rápidamente nuevos proyectos. En este capítulo, los arquetipos incorporados se utilizaron para generar proyectos complejos de Maven, como proyectos web o proyectos de módulos múltiples. También aprendió a crear y usar arquetipos personalizados.
En el próximo capítulo, aprenderá los conceptos básicos de la generación del sitio, la documentación y los informes utilizando Maven.