De um tradutor: alguns anos atrás, estabeleci o objetivo de conhecer rapidamente, mas com bastante firmeza, uma estrutura tão usada como o Apache Maven . Quase imediatamente, consegui encontrar a literatura relevante, mas fiquei um pouco surpreso pelo fato de todos os materiais complexos serem exclusivamente em inglês, enquanto em russo havia muitos artigos espalhados, mas não consegui encontrar um livro completo que pudesse ser lido de capa a capa conseguiu. Como resultado, para a leitura, escolhi um pequeno livro, Introducing Maven, escrito por Balaji Varnasi e Sudha Belida e publicado pela Apress em 2014. Como todas as tarefas foram resolvidas, gradualmente dei à luz uma tradução desta publicação, que, embora esteja na minha mesa há alguns anos, ainda pode ser útil para a comunidade.
Aqui dou uma tradução de apenas um dos capítulos deste livro, mas o todo pode ser baixado aqui desses links em inglês ou em russo (PDF).
Capítulo 6: Arquétipos Maven
Até esse ponto, você criou o projeto Maven manualmente, criando pastas e arquivos
pom.xml do zero. Isso pode ser entediante, especialmente se você costuma criar projetos. Para resolver esse problema, o Maven fornece arquétipos.
Os arquétipos do Maven são projetos predefinidos que permitem aos usuários criar novos projetos com facilidade.
Os arquétipos do Maven também fornecem uma base conveniente para compartilhar experiências e garantir a consistência da estrutura de diretórios padrão do Maven. Por exemplo, uma empresa pode criar um arquétipo com uma folha de estilos em cascata (
CSS ) da empresa, bibliotecas aprovadas por
JavaScript e componentes reutilizáveis. Os desenvolvedores que usam esses arquétipos para criar projetos seguirão automaticamente os padrões da empresa.
Arquétipos incorporados
Fora da caixa, o Maven fornece aos desenvolvedores centenas de arquétipos. Além disso, existem muitos projetos de código aberto que fornecem arquétipos adicionais que você pode baixar e usar. O Maven também fornece arquétipos de plug-in com objetivos para criar arquétipos e gerar projetos a partir de arquétipos.
O plug-in de arquétipo possui um destino de
geração que permite visualizar e selecionar o arquétipo necessário.
A Listagem 6-1 exibe os resultados da execução do destino de geração na linha de comandos. Como você pode ver, 491 arquétipos foram escolhidos
(em 2018 já havia mais de 2 mil - aproximadamente. Transl.) . O uso de vários deles é discutido neste capítulo.
Listagem 6-1. O plugin do arquétipo Maven gera chamada 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:
Criação de projeto da Web
O Maven fornece o
arquétipo maven-archetype-webapp para gerar um aplicativo da web. Vamos criar esse aplicativo chamando o seguinte comando na
pasta C: \ apress \ gswm-book \ chapter6 :
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp
Este comando é executado interativamente. Para perguntas recebidas, insira as seguintes informações:
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>>
A estrutura de pastas gerada deve se parecer com a mostrada na
Figura 6-1 :
Figura 6-1. Estrutura do projeto web Maven
O arquivo
pom.xml é mínimo e contém uma única dependência -
JUnit . O Maven pode simplificar o lançamento do seu aplicativo da Web usando servidores da Web incorporados, como
Tomcat ou
Jetty .
A Listagem 6-2 exibe o arquivo
pom.xml modificado com o plug-in do
Tomcat adicionado.
Listagem 6-2. Arquivo pom.xml modificado com plug-in 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 executar este aplicativo Web no servidor
Tomcat , chame o seguinte comando no diretório raiz do projeto:
mvn tomcat7:run
Você verá um projeto detalhado e uma saída semelhante à mostrada na
Listagem 6-3 .
Listagem 6-3. Saída de comando de execução do 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"]
Agora inicie o seu navegador e vá para
localhost : 8080 / gswm-web / . Você deve ver uma página da web como a mostrada na
Figura 6-2 .
Figura 6-2. Projeto da Web em execução em um navegador
Projeto multimodular
Os projetos Java Enterpise Edition (JEE) geralmente
são divididos em vários módulos para facilitar o desenvolvimento e a manutenção. Cada um desses módulos produz artefatos como
Enterprise JavaBeans (EJBs) , serviços da web, projetos da web e
JARs do cliente. O Maven suporta o desenvolvimento de projetos
JEE tão grandes, permitindo que você hospede vários projetos Maven em outro projeto Maven. A estrutura de um projeto com vários módulos é mostrada na
Figura 6-3 . O projeto pai possui um arquivo
pom.xml e vários projetos Maven.
Figura 6-3. A estrutura de um projeto com vários módulos
Até o final deste capítulo, explicaremos como criar um projeto com vários módulos para uma tarefa na qual você precisa dividir um projeto grande em um aplicativo da web (artefato
WAR ) que fornece uma interface com o usuário, um projeto de serviço (artefato
JAR ) que contém o código da camada de serviço e o projeto
Persistência contendo o código no nível do repositório.
A Figura 6-4 mostra uma representação visual desse cenário.
Figura 6-4. Projeto multimodular Maven
Vamos começar o processo criando um projeto pai. Para fazer isso, execute o seguinte comando em um prompt de comando na pasta 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
O arquétipo
pom-root cria a pasta
gswm-parent e nela o arquivo
pom.xml .
Conforme
mostrado na
Listagem 6-4 , o arquivo
pom.xml gerado possui conteúdo mínimo. Observe que o tipo
pom é especificado na etiqueta de
embalagem do projeto pai.
Listagem 6-4. Arquivo pai 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>
Agora crie um projeto da web executando o seguinte comando na
pasta 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
No processo de geração deste projeto da web, você forneceu ao Maven coordenadas como
groupId ,
version etc., como parâmetros passados para o destino de geração, que criou o projeto
gswm-web .
O próximo passo é criar um projeto de serviço. Na
pasta C: \ apress \ gswm-book \ chapter6 \ gswm-parent, execute o seguinte comando:
mvn archetype:generate -DgroupId=com.apress.gswmbook -DartifactId=gswm-service -Dversion=1.0.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Observe que você não especificou o parâmetro
package , como
O maven-archetype-quickstart cria um projeto
JAR padrão. Observe também o uso do parâmetro
InteractiveMode . Simplesmente diz ao Maven para executar o comando sem solicitar ao usuário nenhuma informação.
Semelhante à etapa anterior, crie o seguinte projeto Java
gswm-repository executando o seguinte comando na
pasta 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
Agora que você possui todos os projetos gerados, consulte o arquivo
pom.xml na pasta
gswm-parent .
A Listagem 6-5 exibe seu conteúdo.
Listagem 6-5. Arquivo pom.xml pai com 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>
O elemento
modules permite declarar módulos filhos em um projeto de vários módulos. À medida que cada módulo é gerado, o Maven os registra como filhos. Além disso, modifica os arquivos
pom.xml dos próprios módulos, adicionando informações sobre o
pom.xml pai
a eles .
A Listagem 6-6 exibe o arquivo
pom.xml do projeto
gswm-web , que especifica o elemento
pom pai.
Listagem 6-6. Arquivo pom.xml do módulo da Web <?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>
Agora que toda a infraestrutura está instalada, você pode montar o próximo projeto. Basta executar o comando
mvn package na pasta
gswm-project , conforme mostrado na
Listagem 6-7 .
Listagem 6-7. Comando do pacote Maven iniciado no diretório do projeto pai 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] ------------------------------------------------------------------------
Criando arquétipos
O Maven fornece várias maneiras de criar um novo arquétipo. Aqui vamos usar um projeto existente para isso.
Vamos começar criando um projeto de protótipo que será usado como base para gerar o arquétipo. Este projeto será compatível com o
Servlet 3.0 e contém um
Status Servlet que retorna um código de status HTTP 200 (“OK” - solicitação bem-sucedida). Em vez de criar um projeto da Web a partir do zero, copie o projeto
gswm-web gerado anteriormente e crie o
protótipo gswm-web na
pasta C: \ apress \ gswm-book \ chapter6 . Faça as seguintes alterações no projeto que você acabou de copiar:
1. Remova todos os outros recursos, como arquivos específicos do
IDE (Ambiente de Desenvolvimento Integrado) (
.project ,
.classpath , etc.) que você não deseja incluir no arquétipo.
2. Substitua o conteúdo do
arquivo web.xml da pasta
webapp / WEB-INF . Isso configurará o aplicativo Web para usar o
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. Adicione a dependência do
Servlet 3.0 ao arquivo
pom.xml . O conteúdo atualizado do
pom.xml é mostrado na
Lista 6-8 .
Listagem 6-8. Arquivo Pom.xml com dependência 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 desenvolveremos um projeto web em Java e, em seguida, criaremos uma pasta chamada
java no diretório
src / main . Da mesma forma, crie as pastas
test / java e
test / resources no diretório
src .
5. Crie o arquivo
AppStatusServlet.java pertencente ao pacote
com.apress.gswmbook.web.servlet no diretório
src / main / java . O pacote
com.apress.gswmbook.web.servlet é convertido na estrutura de pastas
com \ apress \ gswmbook \ web \ servlet . O código-fonte para o arquivo
AppStatusServelet.java é mostrado na
Listagem 6-9 .
Listagem 6-9. Código-fonte para a classe 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); } }
Um projeto de protótipo em estrutura será uma viagem ao representado na
Fig .
6-5 .
Fig. 6-5. Projeto de protótipo gerado
Usando a linha de comando, acesse a
pasta gswm-web-prototype do projeto e execute o seguinte comando:
mvn archetype:create-from-project
No final do comando, você verá a mensagem
Arquétipo criado em destino / fontes-geradas / arquétipo . O arquétipo gerado está localizado na
pasta gswm-web-prototype / target / managed-sources / archetype .
A próxima etapa é transferir o artefato recém-gerado para uma pasta gswm-web-archetype separada para configurá-lo antes da publicação. Para fazer isso, execute as seguintes etapas:
1. Crie a
pasta gswm-web-archetype no diretório
C: \ apress \ gswm-book \ chapter6 .
2. Copie os subdiretórios e os arquivos da
pasta C: \ apress \ gswm-book \ chapter6 \ gswm-web-prototype \ target \ generator- sources \ archetype para a pasta
gswm-web-archetype .
3. Remova o subdiretório de
destino da
pasta C: \ apress \ gswm-book \ chapter6 \ gswm-web-archetype .
A estrutura de pastas do
gswm-web-archetype deve ser semelhante à mostrada na
Figura 6-6 .
Fig. 6-6. Estrutura do projeto de arquétipo da Web
Vamos iniciar o processo de modificação com o arquivo
pom.xml localizado na
pasta gswm-web-archetype \ src \ main \ resources \ archetype-resources . Altere
finalName no
pom.xml de
gswm-web para $ {artifactId}. Durante o processo de criação do projeto, o Maven substituirá a expressão
$ {artifactId} pelo valor fornecido pelo usuário.
Quando um projeto é criado a partir de um arquétipo, o Maven solicita ao usuário o nome do pacote. O Maven cria uma estrutura de pastas correspondente ao pacote localizado no diretório
src / main / java do projeto criado. Em seguida, o Maven move todo o conteúdo da pasta
archetype-resources / src / main / java archetype para este pacote. Porque Se você deseja que o
AppStatusServlet esteja no
subpacote web.servlet , crie a pasta
web / servlet e mova o
AppStatusServlet para lá. O novo local do
AppStatusServlet.java é mostrado na
Figura 6-7 .
Fig. 6-7. AppStatusServlet no pacote web.servlet
Abra
AppStatusServlet.java e altere o nome do
pacote do
pacote $ {package}; no
pacote $ {package} .web.servlet;A etapa final na criação de um arquétipo é executar o seguinte comando na linha de comando, localizada na pasta gswm-web-archetype:
mvn clean install
Usando arquétipos
Após a instalação do arquétipo, a maneira mais fácil de criar um projeto é, na
pasta C: \ apress \ gswm-book \ chapter6 , execute o seguinte comando:
mvn archetype:generate -DarchetypeCatalog=local
Em resposta às consultas do Maven, insira os valores mostrados na
Lista 6-10 e você verá o projeto criado.
Listagem 6-10. Criando um novo projeto usando um arquétipo 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 o arquivo
pom.xml para
test-project já contém o plug-in
Tomcat e execute o comando
mvn tomcat7: run na pasta
C: \ apress \ gswmbook \ chapter6 \ test-project para iniciar o
projeto . Abra um navegador e acesse
localhost : 8080 / test-project / status . Você verá a inscrição
OK , como mostra a
Figura 6-8 .
Fig. 6-8. Página gerada pelo projeto gerado
Sumário
Os arquétipos do Maven são stubs de projetos que permitem iniciar rapidamente novos projetos. Neste capítulo, arquétipos embutidos foram usados para gerar projetos complexos do Maven, como projetos da Web ou projetos com vários módulos. Você também aprendeu como criar e usar arquétipos personalizados.
No próximo capítulo, você aprenderá os conceitos básicos de geração, documentação e geração de relatórios usando o Maven.