Introdução ao Maven

O Apache Maven é uma ferramenta de automatização de construção (build automation) para projetos Java. Toma o seu código-fonte e produz um entregável (um ficheiro .jar ou .war) ao orquestrar todas as etapas: compilação, testes, empacotamento, gestão das dependências.

Concretamente, o Maven responde a três necessidades fundamentais:

O coração do Maven é um ficheiro único, o pom.xml (Project Object Model), que descreve o projeto: a sua identidade, as suas dependências e a forma de o construir. É a « receita » que o Maven executa.

Sem Maven, construir um projeto Java significa compilar à mão com javac, descarregar cada biblioteca manualmente e gerir sozinho o classpath. O Maven automatiza tudo isto a partir de um só ficheiro.

🔧 Mini-exercício — Cite as três necessidades fundamentais a que o Maven responde.

Antes do Maven, cada projeto Java era construído « à mão » ou com scripts caseiros. Isto colocava vários problemas recorrentes:

A ideia mestra: um programador que entra num projeto Maven sabe imediatamente onde está o código, onde estão os testes e como lançar a construção — independentemente da empresa ou do projeto.

# Com Maven, construir um projeto desconhecido resume-se a:
mvn package

O Maven transforma « como construir este projeto? » — uma pergunta que por vezes levava horas — num único comando universal.

🔧 Mini-exercício — Escreva o único comando que basta para construir um projeto Maven desconhecido.

mvn package

O princípio central do Maven é « convenção em vez de configuração » (convention over configuration). Em vez de descrever tudo explicitamente, o Maven parte de valores por omissão sensatos. Se respeitar as convenções, quase não tem nada a configurar.

Exemplos de convenções por omissão:

Comparemos as filosofias:

Pode sempre redefinir as convenções se necessário, mas 95 % dos projetos contentam-se com os valores por omissão. Menos configuração = menos bugs.

Todo o projeto Maven segue a mesma árvore. Conhecê-la permite navegar instantaneamente em qualquer projeto.

Detalhe das pastas:

🔧 Mini-exercício — Em que pasta deve colocar uma classe de teste unitário, e em qual um ficheiro application.properties?

# Árvore típica vista na linha de comandos
mon-projet/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/        # ex. com/exemple/App.java
│   │   └── resources/   # ex. application.properties
│   └── test/
│       └── java/        # ex. com/exemple/AppTest.java
└── target/              # gerado: não versionar (.gitignore)

⚠️ A pasta target/ é regenerada em cada build. Acrescente-a ao .gitignore: nunca se versionam artefactos compilados.

O Maven precisa de um JDK (Java Development Kit) já instalado, porque se apoia no compilador javac. A variável JAVA_HOME deve apontar para esse JDK.

Consoante o seu sistema:

Instalação manual (todas as plataformas):

# 1. Verificar primeiro que o Java está presente
java -version
# Deve mostrar uma versão 17+ por exemplo

# 2. Definir JAVA_HOME (exemplo Linux/macOS)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

# 3. Descarregar o Maven em maven.apache.org, descomprimir,
#    depois acrescentar a pasta bin/ ao PATH
export PATH=$PATH:/opt/apache-maven-3.9.6/bin

No Windows, JAVA_HOME regula-se em « Variáveis de ambiente ». No Linux/macOS, acrescente a linha export ao seu ~/.bashrc ou ~/.zshrc para que seja permanente.

Com o Maven instalado, verifica-se que funciona e gera-se um primeiro esqueleto de projeto.

# Verificar a versão instalada
mvn -version

Saída típica:

Apache Maven 3.9.6
Maven home: /opt/apache-maven-3.9.6
Java version: 17.0.9, vendor: Eclipse Adoptium

Para gerar um projeto vazio que respeita as convenções, usa-se um arquétipo (um modelo):

# Gera um projeto « quickstart » padrão
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

O primeiro mvn é lento: o Maven descarrega os seus próprios plugins num cache local (~/.m2/repository). Os builds seguintes são muito mais rápidos.

🔧 Mini-exercício — Escreva o comando que mostra a versão do Maven instalada (e a do Java).

mvn -version

Question 1

O que designa o ficheiro pom.xml num projeto Maven?

a) O código-fonte principal da aplicação

b) O Project Object Model: a receita que descreve o projeto e o seu build

c) O resultado compilado do projeto

d) Um ficheiro de logs

Question 2

Onde o Maven espera encontrar o código-fonte principal por omissão?

a) code/

b) target/main

c) src/main/java

d) java/source

Question 3

O que significa « convenção em vez de configuração »?

a) É preciso configurar tudo explicitamente

b) O Maven usa valores por omissão sensatos, reduzindo a configuração necessária

c) Nunca se pode mudar o comportamento do Maven

d) O Maven não tem ficheiro de configuração

Question 4

Que pasta é gerada automaticamente pelo Maven e não deve ser versionada?

a) src/main/java

b) src/test/java

c) target/

d) resources/

Question 5

De que precisa o Maven para funcionar?

a) De um servidor web

b) De um JDK instalado e de JAVA_HOME configurado

c) De uma base de dados

d) De Node.js

Instrução

Verifique a sua instalação do Maven, gere um projeto « quickstart » chamado mon-app no grupo com.exemple, depois construa-o e localize o artefacto produzido.

Correção — Sequência de comandos esperada

# 1. Verificar Maven e Java
mvn -version

# 2. Gerar o projeto a partir do arquétipo quickstart
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

# 3. Entrar no projeto e inspecionar a estrutura
cd mon-app
ls -R          # ou « tree » se disponível

# 4. Construir o projeto
mvn package

# 5. Localizar o artefacto gerado
ls target/

Resultado esperado:

target/
├── classes/
├── mon-app-1.0-SNAPSHOT.jar   <-- o artefacto produzido
└── ...
BUILD SUCCESS

A árvore gerada deve conter:

mon-app/
├── pom.xml
└── src/
    ├── main/java/com/exemple/App.java
    └── test/java/com/exemple/AppTest.java

Se mvn package mostrar BUILD SUCCESS e um .jar aparecer em target/, a sua cadeia Maven está operacional. O sufixo -SNAPSHOT indica uma versão em desenvolvimento (ver lição 02).

Pontos a reter

1. O Maven é uma ferramenta de automatização de build para Java: compila, testa, empacota e gere as dependências.
2. O pom.xml é a receita única que descreve o projeto e o seu build.
3. Convenção em vez de configuração: valores por omissão minimizam o que tem de escrever.
4. Estrutura padrão: src/main/java, src/test/java, src/main/resources, saída em target/.
5. O Maven exige um JDK e JAVA_HOME; verifica-se com mvn -version.

A continuação

Lição 02 — O ficheiro pom.xml: dissecar em detalhe a receita do Maven — coordenadas do projeto, propriedades e herança parent.