Criando projetos Java com Maven

Nesse artigo iremos usar o Maven para criar um projeto Java simples. Precisaremos de aproximadamente 15 minutos, seu editor de texto ou IDE favorito e o Jdk 6 ou mais recente.

Como completar esse tutorial

Como a maioria dos tutoriais Spring, você pode começar do zero e completar cada etapa ou pode pular os passos mais básicos com os quais você já esteja familiarizado. De qualquer maneira, você terminará com um código funcional.
Para começar do zero, vá pra a seção Configure o seu projeto.
Para pular as etapas mais básicas, execute os seguintes comandos:

Baixe e descompacte o código fonte desse artigo, ou clone o repositório usando o Git:
```
git clone https://github.com/spring-guides/gs-maven.git
```
vá para o diretório gs-maven/initial
Pule para a seção Instalação do Gradle

Quando você terminar, pode verificar o resultado com o código em gs-maven/complete.

Configure o projeto

Para começar, você deve criar um projeto Java para ser compilado pelo Maven. Para que possamos focar no Maven, iremos utilizar o projeto mais simples possível.

Crie a estrutura de diretórios

Em um diretório de projeto de sua escolha, cria a estrutura de diretórios abaixo; por exemplo, em sistemas *nix você pode usar o comando mkdir -p src/main/java/hello para fazer isso:

└── src
    └── main
        └── java
            └── hello

Dentro do diretório src/main/java/hello, você pode adicionar qualquer classe Java que quiser. Por questão de simplicidade e consistência, o Spring recomenda que você crie duas classes: HelloWorld.java e Greeter.java.

src/main/java/hello/HelloWorld.java

package hello;
public class HelloWorld {
    public static void main(String[] args) {
        Greeter greeter = new Greeter();
        System.out.println(greeter.sayHello());
    }
}

src/main/java/hello/Greeter.java

package hello;
public class Greeter {
    public String sayHello() {
        return "Hello world!";
    }
}

Agora que você tem um projeto pronto para ser compilado com o Maven, o próximo passo é instalar o Maven.

O Maven pode ser baixado como um arquivo zip em http://maven.apache.org/download.cgi. Apenas os binários são necessários, então procure pelo link para apache-maven-{version}-bin.zip ou apache-maven-{version}-bin.tar.gz.

Uma vez que você tiver baixado o arquivo zip, descompacte-o em seu computador e adicione o diretório bin ao seu path.

Para testar a instalação do Maven, execute-o na linha de comando:

mvn -v

Se tudo correr bem, deve ser mostrada algumas informações sobre a instalação do Maven, que irá parecer com o seguinte (talvez com algumas diferenças):

Apache Maven 3.0.5 (r01de14724cdef164cd33c7c8c2fe155faf9602da; 2013-02-19 07:51:28-0600)
Maven home: /usr/share/maven
Java version: 1.7.0_09, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.7.0_09.jdk/Contents/Home/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "mac os x", version: "10.8.3", arch: "x86_64", family: "mac"

Parabéns! Você agora possui o Maven instalado.

Defina um arquivo de compilação simples

Agora que o Maven foi instalado, você precisa criar um arquivo de definição de projeto. Projetos do Maven são definidos com um arquivo XML chamado pom.xml. Entre outras coisas, esse arquivo irá informar o nome do projeto, versão, e dependências que o projeto necessita buscar em bibliotecas externas.

Crie um arquivo chamado pom.xml na raiz do diretório do projeto e insira nele o seguinte conteúdo:

pom.xml

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework</groupId>
    <artifactId>gs-maven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Como a exceção do elemento opcional <packaging>, este é o mais simples arquivo pom.xml possível necessário para compilar um projeto Java. Ele inclui os seguintes detalhes sobre a configuração do projeto:

<modelVersion>. versão do model POM (sempre 4.0.0).
<groupId>. Grupo ou organização a qual o projeto pertence. Frequentemente expresso como o nome do domínio invertido.
<artifactId>. Nome a ser dado para o artefato da biblioteca do projeto (por exemplo, o nome do arquivo JAR ou WAR).
<version>. Versão do projeto que está sendo compilado.
<packaging> – Como o projeto deve ser empacotado. O padrão é jar para empacotamento em um arquivo JAR. Use war para empacotar em um arquivo WAR.

Quando é preciso escolher o esquema de versionamento, o Sprng recomenda o versionamento semântico(http://semver.org).

Neste ponto, você possui um projeto Maven minimo mas funcional definido.

Compile o código Java

O Maven agora está pronto para compilar o projeto. Você pode executar diversos alvos do ciclo de vida da aplicação com o Maven, incluindo compilação do código do projeto, criar um pacote de biblioteca (como um arquivo JAR) e instalar a biblioteca no repositório de bibliotecas do Maven.

Para compilar, use o seguinte comando no terminal:

mvn compile

Isso irá executar o Maven dizendo para executar o alvo compile. Ao final dessa execução, você deve encontrar os arquivos .class compilados no diretório target/classes.

Como é improvável que você queira distribuir sua aplicação ou trabalhar o seu projeto com arquivos .class diretamente, você provavelmente irá querer executar também o alvo package:

mvn package

O alvo package irá compilar o seu código Java, executar qualquer teste implementado, e finaliza empacotando o código em um arquivo JAR que é salvo no diretório target. O nome do arquivo JAR será baseado no <artifact> e <version> do projeto. Por exemplo, dado o arquivo pom.xml mínimo acima, o arquivo JAR receberá o nome gs-maven-0.1.0.jar.

Se você alterar o valor de <packaging> de “jar” para “war“, o resultado será um arquivo WAR dentro no diretório target ao invés dum arquivo JAR.

O Maven também mantém um repositório de dependências em sua máquina local (usualmente no diretório .m2/repository em sua pasta de usuário) para acesso rápido às dependência do projeto. Se você quiser instalar o arquivo JAR nesse repositório local, deve chamar o alvo install:

mvn install

O alvo install irá compilar, testar e empacotar o código de seu projeto e depois copia-lo para o repositório local de dependências, deixado ele pronto para ser usado por outro projeto.

Falando de dependências, agora chegou o momento de declarar as dependências para a compilação do projeto.

Declare as dependências

O Hello World do exemplo desse artigo é completamente auto-suficiente e não precisa de nenhuma biblioteca adicional. A maioria das aplicações, porém, dependem de bibliotecas externas para lidar com funcionalidades comuns ou mais complexas.

Por exemplo, suponha que além de imprimir na tela a mensagem “Hello World”, você queira que a aplicação mostre a data e hora atual. Você pode usar os recursos de data e hora das bibliotecas nativas do Java, mas pode fazer coisas mais interessantes usando as bibliotecas Joda Time.

Primeiro, altere o arquivo HelloWorld.java para dessa forma:

src/main/java/hello/HelloWorld.java

package hello;
import org.joda.time.LocalTime;
public class HelloWorld {
	public static void main(String[] args) {
		LocalTime currentTime = new LocalTime();
		System.out.println("The current local time is: " + currentTime);
		Greeter greeter = new Greeter();
		System.out.println(greeter.sayHello());
	}
}

Agora HelloWorld usa a classe LocalTime da biblioteca Joda Time para obter e mostra da data atual.

Se você executar mvn compile para compilar o projeto nesse momento, a compilação falhará pois você não declarou a biblioteca Jode Time como uma dependência necessária para a compilação. Para corrigir isso você precisa adicionar as seguintes linhas ao seu arquivo pom.xml (dentro do elemento <project>):

<dependencies>
		<dependency>
			<groupId>joda-time</groupId>
			<artifactId>joda-time</artifactId>
			<version>2.2</version>
		</dependency>
</dependencies>

Esse bloco XML declara uma lista de dependências para o projeto. Especificamente, declara uma dependência para a biblioteca Joda Time. Dentro do elemento <dependency>, as coordenadas para a dependência são definidas por três sub-elementos:

<groupId> – O grupo ou organização que a dependência pertence.
<artifactId> – A biblioteca que é necessária.
<version> – A versão especifica da biblioteca que é necessária.

Por padrão, todas as dependências são configuradas com o escopo compile. Isto é, elas devem estar disponíveis durante a compilação (e se você estiver criando um arquivo WAR, devem ser incluídas no diretório /WEB-INF/libs do arquivo WAR). Adicionalmente, você pode especificar um elemento <scope> para especificar um desses escopos a seguir:

provided – As dependências são necessárias para a compilação, mas irão ser providas durante a execução por um contêiner que esteja executando o código (por exemplo, a API Java Servlet).
test – As dependências que são usadas para compilar e executar os testes, mas não são necessárias para compilar e executar o código do projeto.

Agora se você executar mvn compile e mvn package, o Maven irá resolver a dependência Joda Time do repositório Maven Central e irá compilar o projeto com sucesso.

Escreva um teste

Em primeiro lugar, adicione o JUnit como dependência em seu pom.xml com o escopo test:

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

Em seguida crie um caso de teste como esse:

src/test/java/hello/GreeterTest.java

package hello;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.*;
import org.junit.Test;
public class GreeterTest {
	private Greeter greeter = new Greeter();
	@Test
	public void greeterSaysHello() {
		assertThat(greeter.sayHello(), containsString("Hello"));
	}
}

O Maven usa um plugin chamado “surefire” para executar testes. A configuração padrão desse plugin compila e executa todas as classes localizadas em src/test/java cujo nome coincida com *Test. Você pode executar os testes a partir do terminal com esse comando:

mvn test

ou somente use mvn install da forma mostrada anteriormente (existe uma definição do ciclo da aplicação onde “test” é incluído como um estágio de “install“).

Abaixo segue o arquivo pom.xml completo:

pom.xml

<?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/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.springframework</groupId>
	<artifactId>gs-maven</artifactId>
	<packaging>jar</packaging>
	<version>0.1.0</version>
	<dependencies>
		<!-- tag::joda[] -->
		<dependency>
			<groupId>joda-time</groupId>
			<artifactId>joda-time</artifactId>
			<version>2.2</version>
		</dependency>
		<!-- end::joda[] -->
		<!-- tag::junit[] -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!-- end::junit[] -->
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-shade-plugin</artifactId>
				<version>2.1</version>
				<executions>
					<execution>
						<phase>package</phase>
						<goals>
							<goal>shade</goal>
						</goals>
						<configuration>
							<transformers>
								<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
									<mainClass>hello.HelloWorld</mainClass>
								</transformer>
							</transformers>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

O arquivo pom.xml completo está usando o Maven Shade Plugin para termos o conveniente recurso de fazer o arquivo JAR executável automaticamente. O foco desse artigo é começar a usar o Maven, não o uso desse plugin.

Sumário

Parabéns! Você acabou de criar um projeto Maven simples mas efetivo para a compilação de projetos Java.

Traduzido de

spring.io