A ferramenta Maven: primeira utilização

Novembro 2016





Maven é uma ferramenta de gestão para projetos Java e Java EE, que permite:
  • Criar uma arborescência standard do código e de seus recursos
  • Fazer o download, atualizar e configurar as bibliotecas necessárias para o projeto
  • Compilar o projeto, realizar testes unitários sobre o código e empacotar o resultado



Baixar e instalar o Maven


Atenção: Para utilizar Maven é preciso um acesso internet e um espaço no disco para armazenar os arquivos baixados.

O software Maven é open source, e está disponível no site oficial da Fundação Apache http://maven.apache.org/ com os nomes "binary.zip" para Windows e "binary.tar.gz" para Unix.

Após o download, descompacte o conteúdo do arquivo em um diretório de sistema ("C:\Program Files\Apache", por exemplo), então você deve definir a variável de ambiente MAVEN_HOME para esse diretório e adicionar o subdiretório \bin na variável de ambiente PATH.

Se você não tiver instalado o JDK para editar o código Java, é o momento de fazê-lo, visitando o site oficial http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html. No mesmo princípio, é necessário também configurar a variável

JAVA_HOME correspondendo ao diretório de instalação da JDK, bem como adicionar o diretório \bin na variável de ambiente PATH.

Em resumo, você deve ter três variáveis de ambiente com estes valores, por exemplo:

JAVA_HOME   C:\Program Files\Java\jdk1.7.0_25
MAVEN_HOME  C:\Program Files\Apache\maven-3.1.0
PATH        %JAVA_HOME%\bin;%MAVEN_HOME%\bin;%PATH%

Para verificar se tudo está instalado, você pode abrir um prompt de comando e digitar o seguinte:

mvn --version

Isso normalmente gerará uma exibição mais ou menos como esta, descrevendo sua configuração:

Apache Maven 3.1.0 (2013-06-28 04:15:32+0200)
Maven home: C:\Program Files\Apache\maven-3.1.0\bin\..
Java version: 1.7.0_25, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.7.0_25\jre
Default locale: fr_FR, platform encoding: Cp1252
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"

Hello Word com Maven


Para fazer mais simples, vamos criar um projeto "hello Word" com Maven e desvelar seu funcionamento. Criar, para tanto, um diretório dedicado a ele (a localização não importa).

Abra um prompt de comando e mova-o para a pasta que você acabou de criar, aqui chegaremos ao cerne da questão!

Gerar o arquétipo


Por enquanto temos uma pasta vazia, vamos pedir a Maven para criar sozinho (ou quase) um projeto básico, digitando o seguinte comando:

mvn archetype:generate

Maven deve, então, se conectar ao repositório central http://repo.maven.apache.org/ e começar por baixar um grande número de arquivo POM (Project Object Model) e JAR (Java Archiver) que lhe serão úteis. Estes serão, em seguida, armazenados. por padrão, na sua pasta "Meus Documentos" no diretório chamado ".M2". Ao armazenar esses arquivos em disco, Maven, não precisará baixá-los na próxima utilização e irá consultá-los diretamente no repositório local.
Se você trabalhar em uma empresa (ou universidade, por exemplo), ele pode estar equipado com um repositório de empresa em um servidor que armazena todos os arquivos baixados pelo Maven na rede e os redistribui aos usuários que precisam localmente, sem ter que passar pelo repositório central (com exceção de uma primeira aplicação), que permite o acesso mais rápido aos arquivos.

Isto esclarecido, seus downloads agora devem estar concluídos e o Maven deve ter indicado que iria construir o projeto no modo interativo.

Quer dizer, ele vai pedir uma série de coisas que deverão ser respondidas, na maioria das vezes, a partir de uma lista de opções padrão.

Primeira pergunta: escolher o tipo de projeto. Aqui Maven fornece vários arquétipos diferentes, eis aqui um exemplo das últimas linhas que você poderia ter:

823: remote -> ru.nikitav.android.archetypes:release (-)
824: remote -> ru.nikitav.android.archetypes:release-robolectric (-)
825: remote -> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)
826: remote -> sk.seges.sesam:sesam-annotation-archetype (-)
827: remote -> tk.skuro:clojure-maven-archetype (A simple Maven archetype for Clojure)
828: remote -> uk.ac.rdg.resc:edal-ncwms-based-webapp (-)

Escolha um número ou aplique o  filtro  (format: [groupId:]artifactId, case sensitive contains): 294:
.
As linhas 1-828 são todas as opções possíveis de projetos. Observação: A lista de projetos pode variar ao longo do tempo, então você talvez não vai ter 828, mas isso não importa. Aqui, só vamos nos preocupar com a opção padrão proposta (294 no meu exemplo), conforme descrito abaixo:

294: remote -> org.apache.maven.archetypes:maven-archetype-quickstart (An archetype which contains a sample Maven project.)

Entremos esse padrão para dizer a Maven que use o arquétipo "quickstart".

Continua com uma segunda pergunta sobre a versão do arquétipo que queremos usar. Mais uma vez vamos ter o valor padrão, que geralmente corresponde à última versão estável. Maven pode então fazer o download do projeto, que deve ser personalizado.

A próxima questão diz respeito ao "groupId", trata-se do nome do seu grupo, por exemplo, aquele do Maven é "org.apache.maven", você pode colocar o que quiser, desde que respeitem a sintaxe esperada, quer dizer, letras minúsculas, sem acentos ou separadas por espaço. Por exemplo, eu vou colocar "org.ccm.maven"

Em seguida, vem o "artifactId", que é simplesmente o nome do projeto, aqui "HelloWorld".

A próxima pergunta diz respeito a versão do projeto. Maven usa muitos números de versões, por isso é importante entender que cada vez que você vai construir seu projeto Maven, seu número de versão pode ser incrementado. Salientamos que é uma versão de "snapshot" e assegure-se que o projeto será realmente considerado como estando em andamento e, assim, que a sua versão não será incrementada. Melhor deixe o valor padrão "1.0-SNAPSHOT".

Em seguida, vem a questão do pacote do projeto, por padrão, Maven propõe o mesmo nome que o groupId, então, vamos lá, "org.ccm.maven"

Pequena recapitulação e solicitação de confirmação com um "Y", e eis nosso primeiro projeto Maven criado!

Nota: teria sido possível conseguir a mesma coisa sem usar o modo interativo, nesse caso, você deve especificar os diversos parâmetros obrigatórios, Maven completa os parâmetros que faltam com os valores padrão.

O que resulta:

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=org.ccm.maven -DartifactId=helloworld -DinteractiveMode=false

Arborescência do projeto


Eis aqui a arquitetura do projeto, gerado com maven-archetype-quickstart e os valores dos parâmetros passados para o modo interativo, acima:


helloworld
| pom.xml
| src
| | main
| | | java
| | | | org
| | | | | ccm
| | | | | | maven
| | | | | | | App.java
| | test
| | | java
| | | | org
| | | | | ccm
| | | | | | maven
| | | | | | | AppTest.java

Nous avons donc 12 dossiers et 3 fichiers, dont voici le détail :

helloworld/src/main/java/org/ccm/maven/App.java :

package org.ccm.maven;

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

Nada complicado até aqui. Maven somente nos preencheu o código de um clássico Hello World.

helloworld/src/main/java/org/ccm/maven/App.java :

package org.ccm.maven;

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


Aqui é um pouco mais complicado se você não conhece o Junit. Trata-se de uma classe de teste unitário, ele permite fazer automaticamente algumas verificações após cada compilação para garantir que as mudanças de código não perturbem o que já está funcionando.

Nota: aqui o teste é falso, ele simplesmente verifica que o verdadeiro é verdadeiro, o que é obviamente correto.

Finalmente, eis o núcleo da ferramenta Maven, que contém toda a configuração do projeto:

helloworld/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>org.ccm.maven</groupId>
  <artifactId>helloworld</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>helloworld</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>


Encontramos, principalmente, os diferentes valores que configuramos, bem como as dependências à Junit para permitir fazer os testes. Ao configurar esta dependência no pom, Maven sabe que deverá baixar a biblioteca do JUnit e associa-la ao projeto para que ele funcione. Você não precisa, desse modo, instalar!

Nós também podemos ver a baliza do pacote, que é um jar. Isso significa que, depois de compilar o código, será arquivado em um arquivo JAR.

No entanto, falta-lhe uma pequena coisa, pois, na verdade, .jar não é executado (por exemplo, entre a url e as propriedades)

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <addClasspath>true</addClasspath>
              <mainClass>org.ccm.maven.App</mainClass>
            </manifest>
          </archive>
        </configuration>
      </plugin>
    </plugins>
  </build>

Compilando e executando o programa


Agora que o nosso código fonte está completo e a configuração do projeto também, podemos dizer a Maven para construir o projeto. Para tanto, abra um prompt de comando na pasta "HelloWorld" e digite o seguinte comando:

mvn package

Isso vai provocar diferentes ações, a validação do projeto (que vai, principalmente, baixar todos os arquivos que podem estar faltando), compilar o projeto, a execução dos testes unitários e a criação de arquivos jar. Note que, se uma dessas etapas falhar, a seguinte não será executada.

Uma nova pasta apareceu em seu diretório helloworld, trata-se do "target", que contém as classes compiladas (em "classes" para o programa e "test-classes" para os teste unitários), os relatórios de testes ("surefire-reports"), bem como o arquivo "HelloWorld-1.0-SNAPSHOT.jar" e propriedades de compilação (em "maven-arquivo").

Pronto, agora você pode lançar o programa com o comando:

java -jar target/helloworld-1.0-SNAPSHOT.jar

O resultado será como o esperado: Hello World!

Para ir mais longe

  • A descrição do projeto através do pom.xml permite, em particular, se livrar da instalação de dependências. Se você quiser mudar o seu projeto de uma máquina para outra, basta copiar as fontes do projeto. A regeneração do projeto se fará exatamente da mesma maneira sem problema de configuração.
  • Após a compilação e o packaging terminado, Maven pode implantar o aplicativo diretamente no servidor e fazer testes de integridade para verificar se a coabitação com as outras aplicações de seu ambiente se passa corretamente.
  • Maven é suportado pelo Eclipse e Netbeans, você pode, então, passar por cima do prompt de comandos e encontrar as funcionalidades de Maven diretamente em seu IDE favorito.
  • Ant é similar ao projeto Maven. Eles podem, às vezes, serem encontrado associados.


Artigo original publicado por KK

Tradução feita por Ana Spadari

Veja também :
Este documento, intitulado « A ferramenta Maven: primeira utilização »a partir de CCM (br.ccm.net) está disponibilizado sob a licença Creative Commons. Você pode copiar, modificar cópias desta página, nas condições estipuladas pela licença, como esta nota aparece claramente.