Primeiras aulas do curso Maven: Build do zero a web

Maven: Build do zero a web

Do zero aos relatórios - Introdução

Olá! Neste curso de Maven, aprenderemos sobre as dificuldades que enfrentamos na construção de um projeto.

Teríamos um trabalho muito grande e cansativo se fossemos fazer tudo manualmente — imagine escrever linhas de compilação de arquivo no terminal, gerir diretórios, gerar um arquivo .war, inserir o manifest, executar o servidor com atualização, e assim por diante.

E o que vamos aprender?

Atuaremos tanto pela linha de comando quanto pelo IDE Eclipse. Espero que você goste do curso!

Vamos começar?

Do zero aos relatórios - Sem Maven é fácil?

Neste curso, analisaremos um projeto que possui código fonte em Java com bibliotecas, arquivos de teste e todos os recursos necessários. A questão é: como transformar tudo isso em um único arquivo e apresentá-lo ao cliente, seja em um formato .war ou .jar? Como podemos utilizar o código fonte de um projeto e executar o build de um artefato final?

Em um primeiro exemplo, estudaremos como se daria esse processo caso ele fosse executado manualmente no terminal. Criaremos uma classe chamada Calculadora, supondo que o nosso programa tenha como finalidade realizar cálculos matemáticos.

Calculadora recebe os argumentos da linha de comando e imprime o resultado da conta 5+5.

public class Calculadora {
    public static void main(String[] args) {
        System.out.println("5 mais 5 é " + (5+5));
    }
} 

Salvaremos nosso arquivo, e pronto! Nosso programa está criado e contém apenas um arquivo, e caso necessário, teremos de criar mais, mas no momento criamos apenas um no pacote raiz, de maneira muito simples.

Analisaremos nosso terminal — caso esteja utilizando o sistema operacional Windows, use o comando dir, e não ls, para acessar os arquivos do diretório. E para compilarmos Calculadora.java, faremos uso do javac. Digitaremos os seguintes comandos:

ls
javac Calculadora.java

Devemos fazer esse procedimento todas as vezes que formos compilar um arquivo, e isso pode se tornar muito cansativo, ainda mais se o projeto tiver vários arquivos. Devemos colocá-los na mesma linha de comando, o que pode não ser um bom método para construirmos nossa aplicação.

javac Calculadora.java Soma.java Subtracao.java

Imagine que façamos alterações simples em nosso código, como calcular novos valores, 6 + 6 ao invés de 5 + 5. Teríamos de acessar o terminal novamente, e compilar o programa. Além de tudo, o processo está confuso, afinal os conteúdos estão armazenados no mesmo diretório. Para organizarmos melhor o nosso projeto, criaremos um diretório chamado calculadora, e moveremos Calculadora.java para esse novo diretório.

javac Calculadora.java
mkdir calculadora
mv Calculadora.java calculadora/
cd calculadora/

Ao abrirmos o diretório calculadora clicando em "File > Open...", veremos que Calculadora.java está armazenado em seu interior. Há ainda um problema: se deixarmos todos os conteúdos em um mesmo diretório teremos dificuldades para realizar a compilação, pois nesse panorama temos todos os arquivos fonte e os artefatos criados em mesmo local.

Separaremos a fonte do build, e criaremos um arquivo fonte, que em inglês seria source. Em programação, é comum utilizarmos a abreviação "src", portanto criaremos um novo diretório com este nome. Moveremos Calculadora.java para src, e assim começamos a organizar melhor o nosso projeto.

A próxima etapa implica em criarmos um diretório em que depositaremos os arquivos gerados, isto é, criaremos o diretório de destino ou alvo. "Alvo" em inglês é traduzido como target, portanto esse será o nome padrão do diretório no qual colocamos nossas classes.

De volta ao terminal, consultaremos com o comando ls quais são os nossos arquivos até agora: src e target, que ainda encontra-se vazio. Queremos compilar Calculadora.java, mas este arquivo está no diretório src, e não na raiz do projeto, portanto devemos passar a instrução para que o Java compile o arquivo Calculadora.java de sourcepath src para o diretório target, por meio do seguinte comando:

javac -sourcepath src -d target src/Calculadora.java 

Assim, o arquivo será compilado. Se usarmos o comando ls target/, teremos que no diretório targetCalculadora.class e, da mesma forma, se utilizarmos ls src/, notaremos que em srcCalculadora.java.

Os comandos estão bem mais complexos, e devemos fazer o mesmo procedimento para todos os arquivos .java. Para adicionar uma dificuldade extra, imagine que nosso projeto utilize uma biblioteca, como o XStream, e que os objetos sejam serializados em XML.

Iremos até o navegador e procuraremos por XStream, faremos o download da biblioteca da versão Core (XStream Core only) que possui apenas os arquivos .jar. Terminado o download temos o arquivo xstream-1.4.8.jar, e incorporaremos a biblioteca ao nosso projeto.

Devemos analisar em qual diretório ela será armazenada, src ou target. Em geral considera-se que bibliotecas sejam source, mas criaremos um diretório chamado lib (de library, ou "biblioteca") seguindo a convenção. Logo, temos três diretórios: src, target e lib.

Como iremos compilar o projeto com base nas fontes do diretório src, armazenando em target e utilizando a biblioteca de lib? Veremos o comando a ser utilizado:

javac -sourcepath src -d target -cp lib/xstream-1.47.jar src/Calculadora.java

Ao executarmos o programa, veremos que a compilação ocorre, mas notem que há um erro na versão da biblioteca, pois o correto seria xstream.1.4.8.jar. Não tivemos nenhuma notificação desse erro, embora não fosse grave! Ao corrigirmos a versão da biblioteca, o programa é novamente compilado, sem que tenhamos ideia se todas as informações estão corretas.

Percebam a dificuldade de fazermos todo o processo de forma manual. O panorama seria ainda mais complexo caso tivéssemos arquivos de teste. Teríamos em nosso projeto um diretório chamado main, que abrigaria Calculadora.java, e um diretório chamado test, que abrigaria os arquivos de teste.

No arquivo test criaríamos uma classe CalculadoraTest:

public class CalculadoraTest {

}

Como compilaríamos esse projeto agora? Faremos a compilação dos arquivos do diretório target e mandaremos isso para o cliente?

O cliente só deve receber a calculadora, portanto devemos separar o teste no diretório target das classes verdadeiras. Ou seja, não é mais no diretório target que devemos realizar a compilação, mas sim em target/classes. Vamos tentar compilar.

javac -sourcepath src -d target/classes -cp lib/xstream-1.4.8.jar src/Calculadora.java

Teremos um erro: o arquivo não foi encontrado ("javac: file not found: src/Calculadora.java"). Isso acontece porque mudamos o diretório. Devemos fazer a alteração de src para src/main.

javac -sourcepath src/main -d target/classes -cp lib/xstream-1.4.8.jar src/main/Calculadora.java

Ao compilarmos novamente, obteremos um novo erro: não foi encontrado o diretório target/classes. Portanto, precisaremos criá-lo.

Feitas as modificações, nosso programa é compilado. Aprendemos quão trabalhoso é lidar com a construção de um projeto manualmente. É possível criar scripts com as mais diversas bibliotecas para facilitar e automatizar o processo de build e criação de artefatos.

Com as ferramentas de criação de build como o próprio Maven — que suporta Java e outras tantas linguagens —, podemos lidar melhor com os arquivos .class do projeto, executar os testes, gerar um arquivo .jar de uma biblioteca, fazer com que um projeto dependa de outro, e mais.

Do zero aos relatórios - Um gostinho do Maven

Vamos buscar o Maven para que possamos realizar seu download. Acessaremos a página oficial do software e escolheremos a opção "Download" no menu principal.

Baixaremos a última versão disponível, de acordo com o sistema operacional em uso. No nosso caso, salvaremos o arquivo apache-maven-3.3.9 no diretório workspace, mas você pode inseri-lo no diretório que faz mais sentido para o seu projeto.

Descompactaremos o aquivo baixado, e um dos diretórios existentes é o bin, no qual clicaremos e teremos acesso ao arquivo mvn. Caso você clique sobre ele, nada acontecerá, porque utilizamos o Maven no terminal. Assim, pelo terminal, acessaremos o diretório apache-maven-3.3.9, e dentro dele o bin. Utilizamos pwd para confirmar o diretório.

cd Documents/guilherme/workspace/
ls
cd apache-maven-3.3.9
cd bin
pwd 

Em bin temos o mvn, e para executarmos este arquivo, iremos acionar ./mvn. Dessa forma rodaremos um script desse diretório. O script é executado, mas recebemos uma mensagem de erro, pois não especificamos nenhum comando. Declaremos mvn e, dessa vez, passaremos o seguinte comando, com que as informações de ajuda são exibidas.

./mvn --help

O Maven é executado corretamente, entretanto não é prático entrarmos neste diretório toda vez que precisarmos acioná-lo. Para solucionarmos esse problema, adicionaremos o diretório atual em nosso path, que no Windows e no Linux são as variáveis de ambiente. Neste caso, voltaremos ao diretório original (cd), que conferiremos por meio do comando pwd.

pwd
/Users/alura/Documents/guilherme/workspace/apache-maven-3.3.9/bin
cd
pwd
/Users/alura

No diretório original queremos editar um arquivo para configurar que o diretório /Users/alura/Documents/guilherme/workspace/apache-maven-3.3.9/bin irá para o path global de execução de arquivos. No Linux, fazemos isso por meio da variável de ambiente que podemos configurar diretamente neste diretório, utilizando o comando vi .bash_profile.

Estamos prontos para editar o arquivo, portanto pressionaremos a tecla "A" para realizar a inserção de conteúdo. Escreveremos o comando export para exportar a configuração de PATH como sendo o atual ($PATH), e (:) o diretório :/Users/alura/Documents/guilherme/workspace/apache-maven-3.3.9/bin. Estamos afirmando que o novo path é composto pelo atual, e pelo novo diretório.

export PATH=$PATH:/Users/alura/Documents/guilherme/workspace/apache-maven-3.3.9/bin

Para salvarmos as modificações, usaremos :wq, porque utilizamos o vi. Caso você tenha utilizado outro editor, salve o arquivo bash_profile no diretório do seu usuário.

Ainda não podemos acionar o mvn, pois ao configurarmos o path devemos reabrir o terminal. Em uma nova aba digitaremos mvn --help, e as informações de ajuda ficarão visíveis no terminal, e isso quer dizer que o Maven foi encontrado no diretório do path.

Temos o Maven descompactado e instalado, e estamos prontos para criar um projeto. Com cd Documents/guilherme/workspace/ solicitaremos que o Maven gere um novo projeto, mas antes precisamos estipular sua estrutura básica ou arquétipo, portanto escreveremos:

mvn archetype:generate

Precisamos passar o nome ou ID do nosso projeto, que será produtos. Digitaremos -DartifactId=produtos para instaurar essa informação.

mvn archetype:generate -DartifactId=produtos

O próximo passo consiste em declararmos o pacote básico da empresa, já que produtos se refere ao projeto em si, isto é, apenas uma parte do pacote. Usaremos -DgroupId=br.com.alura.maven, pois estamos elaborando um curso sobre Maven na Alura.

Desabilitaremos o método interativo usando as informações padrão para configurarmos nosso projeto. Para isso, incluiremos -DinteractiveMode=false:

mvn archetype:generate -DartifactId=produtos -DgroupId=br.com.alura.maven -DinteractiveMode=false

Até agora temos as seguintes solicitações: a criação do projeto (archetype:generate), com o nome produtos, pacote base br.com.alura.maven, e configurações automáticas. Ainda resta uma última solicitação: queremos que o projeto siga um exemplo simples, disponibilizado pelo Maven, e que pode ser utilizado como base.

Para acionarmos o projeto modelo do Maven, usaremos -DarechetypeArtifactId. Se buscarmos esse termo no Google, por exemplo, encontraremos diferentes tipos de projeto modelo.

Caso precisemos de um start rápido com Spring MVC, basta procurarmos qual ArchetypeArtifactId é usado para criar um projeto com estas características usando Maven. Você pode variar as ferramentas de acordo com seu interesse. No nosso caso, queremos um modelo simples e rápido, portanto buscaremos o ArchetypeArtifactId quickstart no Google. No terminal, incluiremos o resultado da nossa pesquisa, -DarchetypeArtifactId=maven-archetype-quickstart, desse modo teremos um modelo de projeto a ser seguido.

mvn archetype:generate -DartifactId=produtos -DgroupId=br.com.alura.maven -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-quickstart

Após pressionarmos o botão "Enter", será feito o download de várias informações. Existe um ditado de que o "Maven baixa a internet inteira", pela quantidade de conteúdos que ele insere no projeto. Qualquer programa de build "baixa a internet inteira", e entenderemos melhor isso analisando o Maven.

O Maven possui um core muito pequeno, por isso seu download é tão rápido. Todas as ferramentas utilizadas por este software são plugins, portanto na primeira vez em que ele é executado são feitas as captações dos elementos que de fato serão necessários para a construção do projeto.

Neste instante, estamos inserindo uma série de bibliotecas que irão possibilitar a construção do nosso projeto. Todas as vezes em que precisarmos de algo indisponível no Maven, ele irá fazer o download do plugin necessário automaticamente.

Terminado o processo de baixar todos os conteúdos, será criado o modelo de projeto. No diretório workspace, passaremos a ter produtos. Dentro deste, encontraremos src, que por sua vez abriga mais duas pastas, main e test, o código principal e o de teste, respectivamente. Abriremos o projeto produtos no editor Sublime, para que possamos visualizar sua estrutura com mais clareza. Abriremos o seguinte arquivo no editor: "produtos > src > main > java > br > com > alura > maven > App.java".

O Maven cria automaticamente uma classe App no diretório br.com.alura.maven, dentro da qual há o método main, apenas como exemplo.

package br.com.alura.maven;

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

No diretório test, temos "test > java > br > com > alura > maven > AppTest". Na classe AppTest há um construtor e alguns métodos simples, e assim temos um pequeno exemplo de teste.

package br.com.alura.maven;

import junit.framework.Test;
import junit.framework.TestCase; 
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
*Unit test for simple Apps
*/
public class AppTest
    extends TestCase
{
    /**
    *Create the test case
    *
    * @param testName name of the test case
    * /
    public AppTest( String testName )
    { 
        super( testName );
    }

    /**
    * @return the suit of tests being tested
    */
    public static Test suite()
    {
        return new TestSuite(AppTest.class);
    }

    /**
    * Rugourous Test :-)
    */
    public void testApp()
    {
        assertTrue( true );
    }
}

O arquétipo que utilizamos cria uma estrutura de código fonte de Java principal e de teste. Temos, ainda, um arquivo em XML, o pom.xml que estudaremos mais adiante. Por ora, devemos lembrar que criar um projeto não costuma ser a parte mais difícil, porém o Maven nos auxilia também nessa parte.

Além disso, ele nos ajuda a compilar todo o processo de build, e não precisamos fazer toda a compilação manualmente, basta solicitarmos que o software realize todo esse processo para nós por meio do comando mvn compile.

Na primeira vez em que o Maven compila um projeto, ele irá baixar o plugin de compilação e outras bibliotecas necessárias. No caso do nosso projeto, aparentemente não precisamos de nenhuma biblioteca por enquanto. Ao final da instalação dos conteúdos, teremos a seguinte mensagem:

[INFO] Compiling 1 source file to /Users/alura/Documents/guilherme/workspace/produtos/target/classes

O Maven compila um arquivo para o diretório target/classes que contém o arquivo App.class. Se precisarmos refazer a compilação, o Maven não irá realizar todas as instalações novamente. De forma geral, as ferramentas de build precisam baixar as dependências em algum momento, e conforme o projeto vai se tornando cada vez mais complexo, novas necessidades são criadas.

Para compilarmos a classe de teste, basta usarmos mvn test no terminal. Como estamos compilando uma classe de teste pela primeira vez, os plugins relacionados e possíveis bibliotecas necessárias serão baixadas. Por exemplo, é comum usarmos o JUnity, portanto o download desse framework é realizado. Temos também o download do Surefire, que gera o relatório de teste, por exemplo.

Caso executemos o teste novamente, nada novo será baixado, e o processo será bem mais rápido. No diretório target, haverá uma nova pasta chamada surefire-reports, que abriga arquivos TXT em que o resultado do teste em cada classe é exibido. Como só temos a classe AppTest, teremos um único relatório.

À medida em que formos criando novas classes, novos relatórios serão gerados. Na prática, criaremos um arquivo no diretório maven, que conterá uma classe que chamaremos de Produto. Essa nova classe está inserida do pacote br.com.alura.maven.

package br.com.alura.maven;

public class Produto { 

} 

Uma vez que a classe Produto tiver sido criada, voltaremos ao terminal e executaremos a compilação por meio de mvn compile, que já conhecemos bem. Ao final, teremos dois arquivos fonte no diretório classesApp.class e Produto.class.

Existe algo que não analisamos com profundidade: a classe AppTest possui algumas importações do JUnit, uma biblioteca, isto é, um arquivo .jar.

package br.com.alura.maven;

import junit.framework.Test;
import junit.framework.TestCase; 
import junit.framework.TestCase;
import junit.framework.TestSuite;

Para que esse arquivo seja executado, o .jar deve estar no classpath. Como o Maven decidiu que precisávamos do .jar? Todas as informações estão no arquivo pom.xml, o modelo do nosso projeto.

Ao acessá-lo, perceberemos que ele configura sua própria versão (4.0.0), e essa informação não será alterada. Veremos que nosso projeto está no grupo br.com.alura.maven, seu nome é produtos, e ele gera um .jar. Temos ainda a versão atual 1.0-SNAPSHOT em <url>, e podemos colocar o site do nosso projeto, como http://www.alura.com.br, com o qual temos as dependências.

<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>br.com.alura.maven</groupId>
    <artifactId>produtos</artifactId> 
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>produtos</name>
    <url>http://www.alura.com.br</url>
    <dependencies>
        <dependency> 
            <groupId>junit</groupId>
            <artifactId>jnuit</artifactId>
            <version>3.8.1</version> 
            <scope>test</scope>
        </dependency> 
    <dependencies> 
</project> 

Reparem que há uma dependência para o JUnit, cuja versão inserida por padrão é bem antiga. Na prática, utilizamos versões bem mais novas, e podemos modificar essa informação. Mais abaixo, temos o <scope>, e caso o arquivo seja apenas para teste, é inserida a palavra test, caso seja também para execução, não precisamos inserir nada, afinal a execução é o padrão.

Esta é apenas uma amostra do que é trabalhar com o Maven na linha de comando. Ao invés de realizarmos tudo manualmente, podemos utilizar comandos como mvn test para testar o seu projeto, ou mvn clean para limpá-lo. Além disso, existem plugins para uma infinidade de ações, e nós estudaremos mais as possibilidades do Maven ao longo do curso.

Sobre o curso Maven: Build do zero a web

O curso Maven: Build do zero a web possui 175 minutos de vídeos, em um total de 50 atividades. Gostou? Conheça nossos outros cursos de DevOps em Infraestrutura, ou leia nossos artigos de Infraestrutura.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda DevOps acessando integralmente esse e outros cursos, comece hoje!

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

Premium

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$75
à vista R$900
Matricule-se

Premium Plus

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$100
à vista R$1.200
Matricule-se

Max

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$120
à vista R$1.440
Matricule-se
Procurando planos para empresas?
Acesso por 1 ano
Estude 24h/dia onde e quando quiser
Novos cursos toda semana