Depois de algum tempo desenvolvendo em Java é comum que você esbarre em alguns problemas a medida que seus projetos vão crescendo, e ficando cada vez mais complexos. Por exemplo:
- Controlar as bibliotecas que você utiliza, e as bibliotecas que essas precisam
- Manter sincronizados vários projetos, que dependem uns dos outros
- Ter que se lembrar de gerar vários artefatos, para consumir ou expor webservices, processar XML ou então fazer enhance das classes de domínio em um projeto JPA
- Configurar todo projeto do zero para novos desenvolvedores
- Configurar builds automáticos para integração contínua
- Gerar estatísticas a respeito do seu projeto
Alguns desses problemas podem ser resolvidos por IDEs mais espertas, outros por ferramentas como o ANT. Mas depender de uma IDE específica pode limitar a capacidade de automatizar os builds do seu projeto, e o ANT sozinho não resolve o problema das dependências do projeto.
Para resolver esses problemas existe o
Apache Maven. Segundo o seu site Maven é:
... a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.
Ou seja, utilizando um arquivo de meta-dados, você consegue descrever todo o seu projeto, e os recursos necessários para poder desenvolver, compilar e executar tudo de forma automática.
O arquivo que descreve esses meta-dados se chama pom.xml, e por convenção fica na raiz do seu projeto. E falando em convenção, o Maven utiliza o conceito de conversão sobre configuração, que no geral significa que se você fizer as coisas do jeito que o Maven espera não vai precisar configurar quase nada.
A estrutura de pastas de um projeto web configurado para utilizar Maven é igual a que está na figura abaixo:
Um arquivo pom.xml bem simples é parecido com o exemplo abaixo:
<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>
<parent>
<artifactId>mixer</artifactId>
<groupId>com.b2w.m3</groupId>
<version>2.5-SNAPSHOT</version>
</parent>
<artifactId>web</artifactId>
<groupId>${parent.groupId}</groupId>
<version>${parent.version}</version>
<packaging>war</packaging>
<name>web</name>
<build>
<resources>
<resource>
<filtering>true</filtering>
<directory>src/main/webapp</directory>
<includes>
<include>**/*.html</include>
</includes>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
O
pom.xml tem 3 partes básicas:
- identificação do projeto - Aqui você vai definir as informações que irão diferenciar o seu projeto dos demais. Essas informações são muito importantes para que o Maven identifique o seu projeto no meio dos demais que estão em seu repositório, assim você vai poder, por exemplo, re-utilizar o seu projeto futuramente incluindo ele como dependência de outro projeto.
- configurações de build - Essa é a parte onde definimos como o JDK vai processar o seu projeto, configurações de compilador, versão do código e JVM. Além de podermos configurar qualquer pré ou pós processamento que seja necessário. Como por exemplo, geração de artefatos a partir de um WSDL, ou então enhance das classes de persistência.
- dependências - São as bibliotecas e frameworks que você utiliza em seu projeto, o maven faz download e gerencia qualquer dependência adicional. Por exemplo, o hibernate precisa do antlr, mas você não precisa declara-lo, o Maven automaticamente baixa e o coloca no classpath do projeto.
Quem começa a utilizar o Maven normalmente faz para poder gerenciar as dependências do projeto, então vamos começar assim também. Depois de instalar o Maven, vamos configurar um projeto básico com Spring e Hibernate, e configurar o Eclipse para utilizar esse projeto.A boa notícia é que não precisamos criar toda a estrutura do projeto manualmente, podemos usar o plugin
archetype para criar o esqueleto do nosso projeto. Execute o comando abaixo para ter uma lista de templates básicos para escolher:
mvn archetype:generate
Para o nosso teste vamos criar uma aplicação web simples, então escolha a opção com o texto:
internal -> maven-archetype-webapp (A simple Java web application)
O plugin vai perguntar algumas informações básicas sobre o projeto, responda como listado abaixo:
[INFO] artifact org.apache.maven.archetypes:maven-archetype-webapp: checking for updates from central
Define value for groupId: : com.teste
Define value for artifactId: : webapp
Define value for version: 1.0-SNAPSHOT: :
Define value for package: com.teste: :
Confirm properties configuration:
groupId: com.teste
artifactId: webapp
version: 1.0-SNAPSHOT
package: com.teste
Se tudo ocorreu bem, deve ter sido criada uma pasta
webapp com uma estrutura de pastas parecida com a que eu mostrei acima. Mais importante, você tem um arquivo
pom.xml novinho em folha, pronto para ser utilizado. Vamos ver o que tem dentro?
<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>com.teste</groupId>
<artifactId>webapp</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>webapp Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>webapp</finalName>
</build>
</project>
Você pode ver os valores que preenchemos, e mais uma dependência do JUnit, para podermos executar testes unitários. Pois bem, vamos adicionar mais algumas dependências, adicione a esse pom:
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.3.1.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.3.1.GA</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.5</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-mock</artifactId>
<version>2.0.8</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.5.2</version>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>1.8.0.10</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.8.0.GA</version>
</dependency>
Depois de modificar o
pom.xml chegou a hora de integrar o Maven com sua IDE. Se você utiliza Netbeans a partir da versão 6.5 não precisa fazer nada, ele reconhece projetos Maven nativamente, mas caso prefira o Eclipse existem alguns passos a serem dados.
Para gerar os arquivos de projeto que o eclipse precisa, execute esse comando dentro da pasta do projeto maven:
mvn -Dwtpversion=2.0 eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=true
Para criar as variáveis necessárias para o Eclipse encontrar as bibliotecas baixadas pelo Maven, execute o comando abaixo, colocando o caminho para o workspace que você utiliza:
mvn eclipse:configure-workspace -Declipse.workspace=/Projects/Workspaces/maven_tut/
O próximo passo é instalar um
plugin que integre o Maven ao Eclipse, como o
m2eclipse ou o
eclipse iam.
Se você não quer esperar meu próximo passo-a-passo sobre o Maven, eu recomendo ler o ótimo
Better Builds with Maven, que está disponível como
PDF AQUI.
