Ferramentas Java Introdução ao Maven, aprenda como criar e gerenciar projetos Java

Neste artigo veremos como instalar o Maven e como podemos utilizá-lo para nos auxiliar na criação e no gerenciamento de dependência de um projeto Java.

Cleyson Lima 22 de fevereiro de 2021

É um problema comum durante o desenvolvimento de projetos com a linguagem Java termos que baixar arquivos .jar para serem incluídos dentro de nossos projetos e assim podermos utilizar alguma biblioteca que vai nos auxiliar ao longo do desenvolvimento do mesmo.

Porém esse tipo de comportamento é bastante problemático, pois é comum termos que atualizar as versões dessas bibliotecas em nossas aplicações e realizar essa atualização não é algo trivial, é necessário baixar a nova versão do .jar dessa biblioteca e então coloca-la no nosso projeto, isso se torna ainda mais problemático quando estamos desenvolvendo em equipe, pois todos os membros da equipe precisam saber quais .jar e em quais versões são necessários para que o projeto funcione corretamente na máquina de cada um dos desenvolvedores.

Entretanto, atualmente existem diversas ferramentas que nos auxiliam a gerenciar as bibliotecas e automatizar certas tarefas dentro de projetos do ecossistema Java, uma delas é o Maven que vamos explorar um pouco nesse artigo.

Desenvolvedor Java
Formação: Desenvolvedor Java
A formação Desenvolvedor Java da TreinaWeb tem como objetivo apresentar o desenvolvimento através do Java e todo o ecossistema para desenvolvimento da Oracle. Nesta formação, são desde tópicos básicos como o paradigma orientado a objetos, a preparação do ambiente de desenvolvimento para o Java através do Eclipse e o controle de versão de código através do Git e do GitHub. Até aspectos mais avançados como acesso a bancos de dados relacionais e o desenvolvimento de aplicações web com o Java.
CONHEÇA A FORMAÇÃO

O que é o Maven?

O Maven é uma ferramenta de código aberto mantida pela Apache. Trata-se de uma ferramenta de gestão de dependências e um task runner. Em outras palavras, o Maven automatiza os processos de obtenção de dependências e de compilação de projetos Java.

Quando criamos um projeto Maven, este projeto fica atrelado a um arquivo principal: o pom.xml. Neste arquivo POM (Project Object Model), nós descrevemos as dependências de nosso projeto e a maneira como este deve ser compilado. Com o Maven, é possível, por exemplo, automatizar a execução de testes unitários durante a fase de build, entre outras automatizações.

Com o Maven, não temos mais a necessidade de baixarmos as dependências de nosso projeto e as configurar dentro do Build Path/Classpath de nossas aplicações. Se nós precisamos do driver do MySQL, por exemplo, simplesmente registramos essa dependência no pom.xml. As ferramentas de automação do Maven irão detectar esta dependência, baixa-la e configura-la no Build Path/Classpath de nosso projeto.

Instalação do Maven no Windows

Acesse a página oficial do Maven e faça o download dos arquivos binários.

Página de download dos arquivos binários do Maven

Após realizar o download dos arquivos binários do Maven você deve descompactá-los em um local de sua preferência, importante frisar que o local onde você descompactar os arquivos será o local onde o Maven ficará instalado.

Eu irei descompactar o Maven em C:\Program Files\Maven\apache-maven-3.6.3

Arquivos dos Maven descompactados

Agora vem a parte mais complicada do processo de instalação, é necessário colocar o local onde se encontra o script de execução do Maven nas variáveis de ambiente do seu sistema operacional.

Para fazer isso você pode pesquisar por “Editar as variáveis de ambiente do sistema” no menu iniciar e então irá aparecer a seguinte janela:

Print da janela Propriedades do Sistema

Clique no botão “Variáveis de ambiente…” e uma janela semelhante à da imagem abaixo irá ser exibida:

Print da janela Variáveis de Ambiente

Em seguida clique no botão “Novo..” localizado na parte mais inferior da janela, no campo “Nome da variável” coloque “M2_HOME” e no campo “Valor da variável” coloque o caminho para a pasta de instalação do Maven e por fim clique em “OK”:

Print da janela Nova Variável de Sistema

Em seguida clique na variável “Path” localizada na lista de Varáveis do sistema e depois clique no botão “Editar…”, em seguida clique no botão “Novo” que está localizado na nova janela que abriu e adicione o caminho da pasta bin do Maven:

Print da janela Editar Variável de Ambiente

Clique no botão “OK” para fechar a janela “Editar variável de ambiente” e depois clique no “OK” para fechar a janela “Variáveis de Ambiente” e por fim clique no “OK” para fechar a janela “Propriedades do Sistema”.

Para verificar se o Maven foi instalado com sucesso abra um terminal (PowerShell ou Prompt) e execute o comando abaixo:

mvn --version

Caso não ocorra nenhum erro após a execução do comando acima significa que o processo de instalação do Maven foi realizada com sucesso.

Windows - Fundamentos para desenvolvedores
Curso de Windows - Fundamentos para desenvolvedores
CONHEÇA O CURSO

Instalação do Maven no Linux e MacOS

Para realizar a instalação do Maven em sistemas Linux e no MacOS nós vamos utilizar uma ferramenta de gerenciamento de versões chamada SDKMAN!.

Primeiro precisamos instalar o SDKMAN!, para isso execute o comando abaixo:

curl -s "https://get.sdkman.io" | bash

Em seguida execute o comando a seguir:

source "$HOME/.sdkman/bin/sdkman-init.sh"

Para confirmar que a instalação do SDKMAN! foi executada com sucesso execute seguinte comando:

sdk version

Caso não seja apresentado nenhum erro significa que a instalação do SDKMAN! foi um sucesso!

Por fim para realizar a instalação do Maven com o auxílio do SDKMAN! basta executar o seguinte comando:

sdk install maven 3.6.3

E é apenas isso, com o SDKMAN! podemos realizar a instalação de uma nova versão do Maven com apenas um comando. Para confirmar que a instalação do Maven realmente foi efetuada com sucesso basta executar o comando abaixo:

mvn --version

Caso não ocorra nenhum erro após a execução do comando acima significa que o processo de instalação do Maven foi realizada com sucesso.

Linux - Fundamentos para desenvolvedores
Curso de Linux - Fundamentos para desenvolvedores
CONHEÇA O CURSO
macOS - Fundamentos para desenvolvedores
Curso de macOS - Fundamentos para desenvolvedores
CONHEÇA O CURSO

O que são os Maven Archetypes?

Podemos criar nossos projetos Java usando o Maven, esses projetos são criados a partir de templates base que são chamados de archetypes (arquétipos), isso torna o processo mais fácil, pois quando queremos criar um projeto Java EE, por exemplo, é necessário criar uma estrutura de pastas especifica e configurar arquivos XML para que só depois possamos começar a programar a nossa aplicação, com o Maven é possível automatizar essa etapa ao utilizar um arquétipo de um projeto Java EE.

Criando nosso primeiro projeto com o Maven

Com o terminal aberto na pasta onde deseja criar o projeto vamos executar o comando mvn archetype:generate, após a execução desse comando será exibido no terminal a lista de arquétipos disponíveis para a criação do projeto, como vamos criar um projeto Java simples apenas para entender o funcionamento do Maven iremos utilizar o maven-archetype-quickstart, que cria um projeto básico.

Para isso você deve escolher o número correspondente ao arquétipo que deseja utilizar, no meu caso é o número 1733, lembrando que essa ordem pode mudar como tempo, mas não precisa se preocupar procurando qual o número correto, pois caso não coloque nenhuma opção de arquétipo o maven irá utilizar por padrão o maven-archetype-quickstart.

Em seguida é necessário escolher qual a versão do arquétipo, irei utilizar a versão mais recente, que é a versão 1.4, representada pela opção 8.

Após a escolha da versão o Maven irá perguntar quais os valores para a propriedades groupId, artifactId, version e package.

  • groupId: O nome da organização ao qual pertence esse projeto, possui o mesmo padrão de nomenclatura de pacotes, irei colocar como br.com.treinaweb
  • artifcatId: O nome do projeto, irei colocar treinaweb-maven
  • version: A versão do nosso projeto, caso não seja colocado nenhum valor o Maven irá utilizar o valor padrão que é 1.0-SNAPSHOT
  • package: O nome do pacote principal do nosso projeto, é boa pratica colocar a junção do groupId com o artifactId, no meu caso ficará br.com.treinaweb.treinawebmaven, caso não seja passado nenhum valor, o Maven irá assumir o mesmo valor colocado no groupId

Após colocar todos os valores basta confirma-los com o “Y”.

Estrutura de pastas do nosso projeto

Após a execução do comando para a criação do projeto foi criada uma pasta com o mesmo nome informado para o artifactId e dentro desta pasta foi criada uma estrutura de pastas para a organização do nosso projeto, dependendo de qual arquétipo você escolheu essa estrutura de pastas pode ser diferente.

treinaweb-maven
├── pom.xml
└── src
    ├── main
    │   └── java
    │       └── br
    │           └── com
    │               └── treinaweb
    │                   └── treinawebmaven
    │                       └── App.java
    └── test
        └── java
            └── br
                └── com
                    └── treinaweb
                        └── treinawebmaven
                            └── AppTest.java

Dentro da pasta do nosso projeto temos o arquivo pom.xml que contém as informações sobre o projeto e quais as suas dependências, também temos as pastas src que contém a pasta main que irá guardar o código fonte de nosso projeto e a pasta test que irá conter os códigos fontes para os testes automatizados. Dentro de cada uma destas pastas terá uma estrutura de pastas de acordo com o nome definido no package.

Além das pastas já criadas pelo Maven existe uma outra pasta que será criada sempre que executar o comando para que nosso projeto seja compilado, para demonstrar a criação dessa pasta execute o comando mvn compile dentro da pasta do projeto.

Após a execução do comando mvn compile uma nova pasta será criada, a pasta target, essa pasta irá conter os arquivos .class do nosso projeto.

treinaweb-maven
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── br
│   │           └── com
│   │               └── treinaweb
│   │                   └── treinawebmaven
│   │                       └── App.java
│   └── test
│       └── java
│           └── br
│               └── com
│                   └── treinaweb
│                       └── treinawebmaven
│                           └── AppTest.java
└── target
    └── classes
        └── br
            └── com
                └── treinaweb
                    └── treinawebmaven
                        └── App.class

Gerenciamento de dependências com Maven

Para gerenciar as dependências do nosso projeto utilizamos o arquivo pom.xml nele colocamos as informações das bibliotecas que o nosso projeto necessita para funcionar e o Maven se encarrega do download dessas bibliotecas e de adiciona-las no Build Path/Classpath.

O Maven irá buscar por essas dependências em locais chamados de repositórios, existem basicamente dois repositórios, o repositório local que está localizado na pasta .m2/repository e o repositório remoto que está localizado no repositório público do Maven.

Ao adicionar uma nova dependência em nosso projeto, o Maven primeiro realiza a busca em nosso repositório local, caso não encontre irá buscar no repositório remoto e então fazer o download da biblioteca e disponibiliza-la no repositório local, dessa maneira caso você necessite utilizar a mesma biblioteca em outro projeto não será necessário realizar o download novamente.

Entendendo o pom.xml

No momento nosso pom.xml está como descrito abaixo:

<?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>br.com.treinaweb</groupId>
  <artifactId>treinaweb-maven</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>treinaweb-maven</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Não se assuste com o tamanho do arquivo, ele pode parecer complexo à primeira vista, mas ao observar com mais calma verá que ele não é tão difícil de entender.

Podemos dividir o arquivo pom.xml em quatro partes, a primeira possui as coordenadas do projeto, ou seja, os dados que identificam o projeto, como groupid, artifactId e version.

<groupId>br.com.treinaweb</groupId>
<artifactId>treinaweb-maven</artifactId>
<version>1.0-SNAPSHOT</version>

A segunda parte são as propriedades do projeto, essa parte contém informações de encondig e também a versão do Java que estamos utilizando.

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.7</maven.compiler.source>
  <maven.compiler.target>1.7</maven.compiler.target>
</properties>

A terceira parte é onde definimos as dependencias de nosso projeto.

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
</dependencies>

No momento temos apenas uma dependência listada que é o Junit na versão 4.11 que o Maven utiliza por padrão para executar os testes automatizados.

E por último temos as informações de build que dizem como o projeto deve ser compilado pelo Maven, nessa parte também estão descritas quais plugins do Maven o nosso projeto necessita para ser compilado.

<build>
  <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
    <plugins>
      <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
      <plugin>
        <artifactId>maven-clean-plugin</artifactId>
        <version>3.1.0</version>
      </plugin>
      <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.0.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
      </plugin>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.22.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.0.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-install-plugin</artifactId>
        <version>2.5.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-deploy-plugin</artifactId>
        <version>2.8.2</version>
      </plugin>
      <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
      <plugin>
        <artifactId>maven-site-plugin</artifactId>
        <version>3.7.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-project-info-reports-plugin</artifactId>
        <version>3.0.0</version>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

Executando nosso Hello World

Quando criamos um projeto com o Maven já é criado um arquivo chamado App.java dentro do nosso pacote principal, esse arquivo possui um simples Hello World e podemos executar esse código de diversas formas, uma delas é através do comando mvn exec:java -Dexec.mainClass="br.com.treinaweb.treinawebmaven.App"

Caso não queira ter que passar o parâmetro -Dexec.mainClass toda vez que quiser executar o seu projeto é necessário configurar o plugin de execução do Maven, essa configuração é feita no arquivo pom.xml , para isso vá na parte de plugins do arquivo pom.xml e adicione o código abaixo:

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>3.0.0</version>
  <executions>
    <execution>
      <goals>
        <goal>java</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <mainClass>br.com.treinaweb.treinawebmaven.App</mainClass>
  </configuration>
</plugin>

Com o código acima estamos adicionando uma configuração para o plugin de execução do Maven, nessa configuração estamos dizendo qual a classe principal do nosso projeto, assim para podermos executar nosso código não será mais necessário passar o parâmetro -Dexec.mainClass no comando mvn exec:java.

Adicionando dependências em nosso projeto

Para adicionarmos uma nova dependência em nosso projeto basta que no arquivo pom.xmldentro da tag dependencies adicionemos uma nova tag dependency com as informações de groupId, artifactId e version da biblioteca que queremos adicionar como dependência.

Digamos que vamos desenvolver uma aplicação que realiza requisições HTTP para algum serviço na web, então precisamos de alguma forma realizar essas requisições através do nosso código Java, uma ótima forma de fazer isso é através da biblioteca Apache HttpClient, então para adicionarmos essa biblioteca como dependência em nosso projeto temos que adicionar suas informações no nosso arquivo pom.xml

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>

  <!-- Informações da biblioteca Apache HttpClient -->
  <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
      <version>4.5.13</version>
  </dependency>
</dependencies>

Com isso o Maven irá realizar o download da biblioteca Apache HttpClient e adiciona-la em nosso Build Path/Classpath e então já poderemos utiliza-la em nosso projeto sem mais nenhum trabalho adicional.

Atualizando nosso projeto para usar o Apache HttpClient

Para proposito de exemplificação, vamos alterar o código do arquivo App.java para que ele utilize a biblioteca Apache HttpClint e realize uma requisição HTTP para a API Viacep e então exiba no terminal os dados do CEP que for passado como parâmetro na execução do nosso projeto.

Altere o código do arquivo App.java para ficar de acordo com o exemplo abaixo:

package br.com.treinaweb.treinawebmaven;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

public class App {
    public static void main( String[] args ) {
        String url = "https://viacep.com.br/ws/" + args[0] + "/json/";

        try {
            CloseableHttpClient client = HttpClientBuilder.create().build();
            CloseableHttpResponse response = client.execute(new HttpGet(url));
            String json = EntityUtils.toString(response.getEntity());

            System.out.println(json);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Agora precisamos executar o projeto com o Maven para que possamos ver o código funcionando na prática, como precisamos passar um parâmetro na execução do código utilize o seguinte comando mvn exec:java -Dexec.args="01311200" , mas antes de executar nosso projeto é necessário realizar o processo de compilação com o comando mvn compile, dessa maneira estamos utilizando o Maven para executar o projeto e passando como parâmetro a String 01311200.

Conclusão

Nesse artigo tivemos uma introdução a ferramenta Maven, vimos o que é, como realizar a sua instalação, como podemos utiliza-la para criar, compilar e executar os nossos projetos e também como é possível gerenciar as dependências de nossos projetos.

O Maven ainda possui outras funcionalidades como a de empacotar e gerar o build de nosso projeto e ele também pode ser estendido através de diversos plugins que adicionam novas funcionalidades.

Além disso o Maven pode ser integrado com diversas IDE’s como o Intellij IDEA e Eclipse e também com editores de código fonte como o VS Code.

Se você quer conhecer mais sobre essa linguagem, não se esqueça de acessar nosso Guia da linguagem Java. Te esperamos lá 🙂

Deixe seu comentário

Conheça o autor desse artigo

  • Foto Autor Cleyson Lima
    Cleyson Lima

    Professor, programador, fã de One Piece e finge saber cozinhar. Cleyson é graduando em Licenciatura em Informática pelo IFPI - Campus Teresina Zona Sul, nos anos de 2019 e 2020 esteve envolvido em vários projetos coordenados pela secretaria municipal de educação da cidade de Teresina, onde o foco era introduzir alunos da rede pública no mundo da programação e robótica. Hoje é instrutor dos cursos de Spring na TreinaWeb, mas diz que seu coração sempre pertencerá ao Python.

    Posts desse Autor

Artigos relacionados