Conhecendo melhor o Maven

Ao desenvolver um projeto de programação temos que utilizar, muitas vezes, bibliotecas externas ao código feito para conseguir utilizar funcionalidades que já foram feitas por outras pessoas e que é possível utilizar, fazendo referência ao seu autor, economizando tempo de desenvolvimento.

Com o Java isso não é diferente: a linguagem usa dessas bibliotecas com pacotes inseridos em seu projeto Java, tais pacotes vêm de uma origem conhecida para que seja possível o processo de importação. Geralmente é feito o download da biblioteca e em seguida a importação dela no projeto.

Porém, a depender da complexidade do projeto, acaba sendo necessário o uso de diversas bibliotecas, que podem vir a ter problema na versão e/ou compatibilidade com o código; isso pensado em um projeto grande, passa a ser inviável realizar a importação e verificação de cada biblioteca manualmente.

Aqui entra o Maven: uma ferramenta de gerenciamento de dependências que foi feita em Java para auxiliar nos códigos feitos nesta linguagem.

Sobre o Maven (e breve história)

Ao falar da história que levou a sua criação, podemos citar duas ferramentas feitas em Java: Apache Ant e Apache Ivy.

A Apache Ant é uma ferramenta de automação de compilação no desenvolvimento de aplicações, em outras palavras, ela é quem auxilia o desenvolvedor a compilar os arquivos do projeto na ordem correta conforme dependência entre os arquivos. Este projeto é um software livre, com licença Apache.

Já a Apache Ivy é uma ferramenta de gerenciador de pacotes transitivos, Ivy é uma sub-parte do Apache Ant e possui sua funcionalidade focada em resolver as dependências de um projeto e também repositórios JAR, em especial, auxilia na integração e publicação de artefatos dos projetos que a utilizam. Também é um projeto de software livre, sob mesma licença.

O Apache Maven é uma ferramenta de gerenciamento e compreensão de projetos assim como o Apache Ant (ambas feitas em Java) porém possui conceitos e funcionalidades diferentes, em especial podemos falar da base do Maven que é o Modelo de Objeto de Projeto, este modelo organiza todas as informações do projeto em um único arquivo: o pom.xml.

Essa é a forma que o Maven realiza o Build do projeto, ou seja, conforme dependências são requisitadas, o POM é atualizado. O projeto Maven pode possuir módulos e cada módulo pode ter seu respectivo POM sem perder a organização e hierarquia do projeto principal. O Maven também auxilia na construção de relatórios e documentação.

Além disso, também é possível ter plugins que são fases individuais do projeto. O ciclo de vida de construção de um projeto também é um conceito muito importante no Maven, mas falaremos dele depois.

Instalação do Maven

A princípio temos como pré requisito a instalação do JDK, em especial na versão 1.7 ou superior. Após obter o JDK, independente do sistema operacional que esteja utilizando, podemos dar continuidade a instalação do Maven. Caso tenha dúvidas de como instalar o JDK, temos uma sugestão de leitura que pode te ajudar: Meu primeiro programa em Java.

Sobre o Maven, o próprio site sempre sugere o download da versão mais recente, porém também é possível usar versões anteriores. Em especial, é sugerido toda versão 3 em diante pois é uma versão estável desta ferramenta.

Instalando o Maven no Windows

Para instalar o Maven no Windows basta acessar este link para poder fazer o download. É possível baixar o arquivo binário ou o código fonte, conforme desejar. Neste artigo, vamos utilizar a versão 3.8.7 em seu formato binário.

Ao finalizar o download do arquivo, basta extrair ou descompactar a pasta e armazenar a pasta em algum diretório de sua máquina.

Note que na pasta resultante existe um arquivo executável intitulado mvn, ele é o executável do Maven. Com esse arquivo e diretório você pode manusear o Maven e seus projetos como quiser, porém teria que sempre voltar a este diretório para poder realizar isso.

Para poder utilizar o Maven de qualquer diretório da sua máquina, precisamos configurar ele como variável de ambiente. Para isso, seguimos tais passos:

• Abrimos o explorador de arquivos do Windows.

• Selecionamos a seção intitulada ‘Este Computador’.

• Clicamos com o botão direito do mouse e selecionamos a opção Propriedades.

• Após isso uma nova tela surge e nela selecionamos a opção de ‘Configurações avançadas de sistema’.

• Em seguida, selecionamos a seção de ‘Avançado’ e depois clicamos no botão ‘Variáveis de ambientes…’.

• Adicionamos o diretório C:/*/apache-maven-3.8.7 ao final da lista de diretórios com nome M2_HOME, para sinalizar do que se trata.

E, como foi adicionado como variável de ambiente, também é necessário adicionar seu diretório bin na variável PATH (variável do Windows que guarda os diretórios do arquivos executáveis do sistema):

• Ainda na parte de variável de ambiente, selecionamos a variável ‘PATH’ e em seguida o botão ‘Editar’.
• Selecionamos o botão ‘Novo’.
• Adicionamos o diretório C:/*/apache-maven-3.8.7/bin do Maven na lista de diretórios do PATH.
• Clicamos Ok para finalizar a edição do PATH.
• Clicamos em Ok para finalizar a seção de variável de ambiente.

Finalmente, executamos este comando para verificar sua versão Maven no terminal: mvn -version.

Não mencionamos o JDK à toa, como dito anteriormente, o Maven foi feito em Java e para poder usá-lo temos que ter o kit de desenvolvimento Java presente na máquina. E o JDK definido como variável de ambiente, você pode utilizar o Java de qualquer diretório.

Os passos para definir essa variável são os mesmos que foram feitos para adicionar a variável do Maven, a diferença é que o diretório usado é o caminho da pasta do JDK.

Instalando o Maven no Linux

Para instalar o Maven no Linux temos que baixar o arquivo via terminal de comando. Neste exemplo vamos utilizar o arquivo binário porém fique à vontade para utilizar o código fonte. Vamos utilizar a versão 3.8.7 em binário porém dessa vez no formato .tar:

Vamos seguir os passos para instalar o Maven:

 wget https://dlcdn.apache.org/maven/maven-3/3.8.7/binaries/apache-maven-3.8.7-bin.tar.gz
 tar -xvf apache-maven-3.8.7-bin.tar.gz

Lembrando que este link é obtido ao copiar o link presente no arquivo escolhido na página oficial do Maven.

Agora, vamos definir uma variável de ambiente para o Maven acessando o arquivo $home/.profile e adicionando essas informações de nome e diretório da variável, salvamos e fechamos o arquivo:

M2_HOME='/opt/apache-maven-3.8.7' 
PATH="$M2_HOME/bin:$PATH" 
export PATH

Por fim, executamos este comando para verificar sua versão Maven na máquina: mvn -version

Instalando o Maven no MacOS

Para instalar o Maven no MacOS funciona de forma similar a instalação feita no Linux pois são sistemas operacionais baseados em Unix, outro sistema operacional. O mesmo arquivo e formato podem ser utilizados, e a exportação do .tar é feita da mesma forma. Também usamos a versão 3.8.7 do Maven.

O que muda é que na parte de definir uma variável de ambiente, devemos ir nas configurações do perfil ou executar $ source .bash_profile para abrir o arquivo que possui as variáveis, para assim definir o Maven como uma variável.

Ao abrir o arquivo .bash_profile, adicionamos estas informações, salvamos e fechamos o arquivo:

export M2_HOME='/opt/apache-maven-3.8.7' 
PATH="$M2_HOME/bin:$PATH" 
export PATH

Para verificar o Maven na máquina é da mesma forma que no Linux: mvn -version

Ciclo de Vida de Construção

O conceito de Ciclo de Vida de Construção é o conceito central do Maven, é base para realizar o Build (tradução livre: Construção) do projeto Maven. É onde utilizamos a ideia de meta (ou fase) para cada tarefa que desejamos realizar, podemos ter mais de meta em um comando, o Maven vai executar todas as metas de forma sequencial.

Seguimos essa estrutura ao executar metas no Maven com este comando (todos os comandos Maven são iguais para todos os sistemas operacionais):

mvn [nome da meta 01] [nome da meta 02] [nome da meta 03]

Um comando pode ter uma ou mais metas, o Maven irá executar conforme a sequência definida.

Temos três comandos de construção principais:

• default: traduzido do inglês ‘padrão’, é o comando que faz o deploy do projeto, ou seja, a implementação do projeto em algum ambiente.
• clean: é o comando que realiza a limpeza do projeto, limpa o cache e outros dados gerados pelo o projeto.
• site: é o comando que realiza a criação da página web do seu projeto, o pode ser usado como documentação, por exemplo. Este comando é usado após definir estrutura, design e domínio do site, isso é explicado aqui.

Cada comando possui uma série de comandos que são executados para obter o resultado final esperado, é possível ver o exemplo do comando default neste link.

Outros comandos importantes para o desenvolvimento de projetos são:

• install: este comando realiza a instalação do projeto no seu repositório local, adicionando todas as dependências conforme especificado no pom.xml do projeto.
• package: este comando coloca o código compilado do projeto em um pacote, em outras palavras, num formato que pode ser distribuído para uso. Existem diversos formatos, mas os mais utilizados são JAR e WAR.
• test: este comando realiza os testes unitários definidos na pasta src/test do seu projeto.

Também é possível realizar essas metas também via plugins, que são artefatos que provêm fases para o Maven, então as tarefas podem ser realizadas por esse intermédio.

Esses comandos também podem ser feitos via IDEs, como o Intellij e Eclipse, porém às vezes ocorre problema de compatibilidade e os comandos não são executados dessa forma. Por isso, é sempre bom saber como é feito conforme a documentação oficial, neste caso, como é feito via terminal.

O Arquivo pom.xml

O arquivo POM é a base de um projeto Maven, neste arquivo temos todas as informações sobre o projeto e dependências que são importantes para a execução do projeto. É um arquivo que pode e deve ser atualizado conforme necessário, bastando apenas realizar a atualização do projeto via Maven (via terminal ou IDE, o que preferir).

O exemplo utilizado é uma loja de brincos artesanais implementada em Java, onde temos uma classe Produto com alguns atributos: id, nome, quantidade (estoque) e preço unitário. Para isso, temos o arquivo pom.xml configurado com as informações importantes do projeto:

O cabeçalho do project pode parecer confuso porém pode ser entendido da seguinte forma: o elemento project possui o atributo xsi com este namespace, e o xsi possui um esquema definido; por fim, o elemento deve ser validado conforme o esquema especificado. Isso é um padrão para arquivos 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

Agora, partimos para as informações do projeto, isto é, características que definem o projeto não só a nível de Build mas também ao pensar na distribuição do projeto.

<modelVersion>4.0.0</modelVersion>
<groupId>com.alura.latam</groupId>
<artifactId>store</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>store</name>
<description>store of handmade earrings</description>

Temos de início as informações necessárias sobre o projeto:

• project: é a etiqueta raiz, que agrupa as informações do projeto.
• modelVersion: é referente ao modelo POM compatível ao Maven, então é sempre definido como 4.0.0 pois é a versão atual do POM compatível do Maven, ou seja, é a versão que possui suporte do Maven.
• groupId: é referente ao grupo/empresa que o projeto está associado.
• artifactId: é referente ao nome do seu projeto, a identificação do projeto.
• version: é referente a versão atual do projeto (de acordo com seu groupId), pois em projetos grandes acaba ocorrendo diferentes versões, cada versão com dependências específicas então o POM considera isso também.
• name: nome de acordo com o definido no artifactId.
• description: descrição do projeto em um texto curto.

Note que é possível adicionar mais de uma dependência no projeto. O Maven possui um repositório com dependências disponíveis para adicionar no projeto. Cada dependência possui uma ou mais subsequentes, e caso o desenvolvedor deseje não utilizar alguma de suas posteriores é possível realizar a exclusão utilizando a etiqueta exclusions.

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.14</version>
        </dependency>
  </dependencies>

Neste exemplo, temos duas dependências: o JUnit e o XStream. JUnit é um framework criado para a execução de testes unitários de um projeto Java. Já o XStream é uma biblioteca feita em Java para realizar a serialização de objetos para XML e vice-versa.

Podemos ver como essas dependências são usadas no projeto, neste caso, vamos focar no uso do JUnit. Para utilizar o JUnit temos que utilizar a anotação @Test para sinalizar que o método criado será usado para testes. Neste caso, temos uma classe ProductService com dois métodos: um método para checar se o produto está com atributos nulos, e outro método para adicionar o produto a uma lista de produtos da loja.

package com.alura.latam.service;

import java.util.ArrayList;
import java.util.List;

import com.alura.latam.model.Product;

public class ProductService {
    List<Product> listProducts = new ArrayList<Product>();
    public boolean checkProduct(Product product) {
        if( product.getId() != 0 
                && product.getName() != null && product.getName() != ""
                && product.getUnitPrice() != 0 ){               
                return true;
            }
        return false;
    }   
    public boolean addProduct(Product product) {
        if(checkProduct(product)) {
            listProducts.add(product);
            return true;
        }   
        return false;
    }
}

Dado os métodos, agora partimos para a pasta src/test/java que cuida de todos os arquivos Java relacionados a testes do projeto. Nesta pasta temos a classe ProductValidator com métodos para adicionar um produto não nulo e para adicionar um produto nulo:

package com.alura.latam.test;
import org.junit.Test;
import com.alura.latam.model.Product;
import com.alura.latam.service.ProductService;

public class ProductValidator {
    ProductService productService = new ProductService();

    @Test
    public void addProductNotNull() {
        Product example = new Product(1,"Golden Earring", 30, 7.5);
        productService.addProduct(example);
    }
    @Test
    public void addProductNull() {
        Product example2 = new Product();
        productService.addProduct(example2);
    }
}

Em ambos os métodos criamos objetos de Product com valores fixos. Como o exemplo é um loja de brincos, o primeiro método addProductNotNull() cria um produto descrito como 'brinco dourado' (em inglês) e tenta realizar a adição do produto; já o segundo método cria um produto nulo. Com os métodos definidos, podemos executar os testes utilizando o comando Maven mvn test.

Considerando o que foi implementado, o resultado esperado é que ambos os testes sejam concluídos com sucesso, conforme a interface de Testes do IDE informa:

Além disso, temos informações similares às informações do nosso projeto, com o adicional do atributo scope referente ao escopo do projeto, no caso do JUnit, o escopo é de testes. Cada dependência também possui suas dependências, então é possível visualizar as dependências subsequentes junto a elas:

O conceito de dependências é algo sólido no desenvolvimento de projetos pois tira a preocupação do desenvolvedor de ter que realizar o download de tudo que ele precisa manualmente.

O Maven realiza o download do que for necessário e além disso, ao atualizar a versão da dependência basta alterar o valor associado à versão e atualizar o projeto com o comando mvn clean install, e pronto está atualizado sem que a pessoa tenha tal esforço manual. Ao final, seu projeto possui todos os JARs necessários para a execução.

Finalmente, temos o último bloco do ficheiro que se refere aos plugins utilizados no projecto.

   <build>
        <plugins>
          <plugin>
            <groupid>org.apache.Maven.plugins</groupid>
            <artifactId>Maven-Compiler-plugin</artifactId>
            <version>3.10.1</version>
            <configuration>
              <source>11</source>
              <target>11</target>
            </configuration>
          </plugin>
        </plugins>
  </build>

</project>

Note que este arquivo é fechado após a tag '<build>', com o '</project>'. A parte de build armazena os plugins que o projeto usa de acordo com a definição do desenvolvedor.

No nosso exemplo temos o plugin de compilação do Maven e tem a função de compilar todos os arquivos fonte do projeto. Note que você também tem groupid e artifactId de acordo com os itens acima, e também tem a sua versão de uso.

O último detalhe é a etiqueta de configuração: nela definimos a versão de Java - neste caso Java 11 - que compilará os arquivos fonte do projeto e arquivos target (os gerados pelo projeto).

Plugins

A princípio o conceito de plugin é um código utilizado para aprimorar projetos de software. E o próprio Maven diz que sua fonte é baseada em plugins, não é à toa que na documentação oficial existe uma lista de plugins disponíveis.

O Maven difere os plugins entre os de build: que são focados no build do projeto e são especificados na etiqueta <build> do arquivo pom.xml e os plugins de reporte que são utilizados durante a geração do site via Maven (lembra do comando? mvn site), estes são definidos na etiqueta <reporting> do pom.xml.

São os plugins que nos auxiliam na hora de realizar tarefas de construção e configuração de projetos. Target no projeto é o diretório de build, então os targets de um plugin são tarefas de build realizadas para compor a configuração e compilação do projeto. Lembrando que todo plugin segue essa sintaxe para execução via comando:

mvn [nome do plugin]:[target]

Um exemplo legal de Plugin é o Archetype com seu target create, que gera um protótipo de um projeto Maven a partir de um modelo já existente, um arquétipo. É possível utilizar o plugin via comando:

mvn archetype:create

Após este comando, o Archetype solicita informações do seu projeto como o tipo do projeto e as informações iniciais que vimos na seção sobre o pom.xml para finalizar a geração de toda estrutura com suas devidas pastas.

Em comparativo com o Apache Ant, o padrão ao usar targets é diferente. No Ant, é criado um target que chama o javac, enquanto no Maven usamos um target já existente.

No Ant, é o usuário que realiza os comandos no arquivo build.xml como uma linguagem de programação, já o Maven temos o pom.xml como uma estrutura bem definida onde o build é feito com essa estrutura e declarações, algo mais autônomo.

Por fim, vale ressaltar que tais tarefas acabam gerando arquivos compilados do projeto e todos são armazenados na pasta target, sem que seja necessária configuração prévia e manual feita pelo desenvolvedor.

Integração com Linguagens e Frameworks

O Maven é utilizado majoritariamente em projetos Java porém também é muito utilizado para projetos feitos com o framework Spring, ecossistema feito em Java com diversos segmentos essenciais para desenvolvimento de projetos. O arquivo POM junto com a gerência de dependências é uma estrutura conveniente para gerenciar um projeto que usa Spring.

Por fim, ainda que o Maven tenha sido feito em Java e muitos projetos Java sigam usando-o, ele também é utilizado por outras linguagens tais como: C#, Ruby, Scala, e outras.

Conclusão

Neste artigo vimos a história do Maven, como instalar, como utilizar o arquivo de Build feito em XML chamado POM, que utiliza o Modelo de objeto do projeto para estruturar em XML as informações e dependências essenciais para o projeto.

Vimos sobre o Ciclo de Vida de Construção que o Maven utiliza para gerenciar o projeto utilizando tarefas fragmentadas para que essas tarefas - também vistas como fases - sejam independentes entre si.

Além disso, também vimos como o Maven difere das ferramentas anteriores, mostrando uma melhora significativa na gerência de pacotes e automação de projetos; em especial, vimos que com o Maven é possível gerar a documentação do projeto direto via o comando mvn site.

O Maven é muito utilizado no ambiente Java, então também vimos que além dos projetos puramente em Java, o Maven também está presente em projetos Java com Spring, framework em Java que possui diversos segmentos para desenvolvimento de projetos.

Espero que tenha gostado do conteúdo apresentado, e caso tenha interesse em aprender mais sobre Build de projetos e sobre Maven também, fique à vontade de ler a seção seguinte com outros conteúdos relacionados ao que vimos no artigo.

Ler Mais

Para complementar o conteúdo que abordamos neste artigo, selecionamos alguns conteúdos que podem te auxiliar nos estudos de Build e Apache Maven:

• Conhecendo as build tools no mundo Java | #AluraMais
• Artigo: Processo de build com Maven
• Curso: “Maven: gerenciamento de dependências e build de aplicações Java”