Artigo Java Magazine 36 - Conhecendo o Ant

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Artigo Publicado pela Java Magazine 36.

Esse artigo faz parte da revista Java Magazine edição 36. Clique aqui para ler todos os artigos desta edição

jm36.jpg

Conhecendo o Ant

A Ferramenta de Automação Essencial do Desenvolvedor Java

Aprenda a construir scripts Ant básicos e avançados, que podem ser utilizados em qualquer plataforma ou IDE Java do mercado, e automatize dezenas de tarefas fundamentais no desenvolvimento

Fernando Lozano

O Ant não é formalmente parte da Plataforma Java, conforme ditado pelo JCP, mas é de fato parte da rotina de qualquer desenvolvedor Java que não esteja ainda nos primeiros passos de aprendizado da linguagem. A grande maioria dos IDEs Java, além de frameworks e outras ferramentas de apoio ao desenvolvimento Java, se não usam internamente o Ant ao menos fornecem recursos para sua integração com ele.

O Ant é um mecanismo (engine) para a execução de scripts voltados para a construção de software Java. Dessa forma, ele pode ser considerado como um “primo” do popular make dos sistemas Unix (e seus clones no Visual C++ e C++ Builder). Entretanto, o Ant é não só mais poderoso como também é mais portável, sendo a ferramenta perfeita para uma plataforma como o Java, que se propõe a suportar aplicações independentes de sistema operacional e arquitetura de hardware. O quadro “Ant x make” apresenta as semelhanças e diferenças entre o make do Unix e o Ant.

Praticamente todas as tarefas do dia-a-dia de um desenvolvedor Java podem ser realizadas via Ant, desde a compilação de classes Java e construção de pacotes JAR até a inicialização de bancos de dados, atualização de código em um sistema de controle de versões ou geração de relatórios de execução de testes de unidade.

Os primeiros exemplos deste artigo exigem somente o JDK configurado na linha de comando para serem executados pelo leitor. Entretanto, exemplos posteriores irão exigir o Tomcat 5.5.x instalado. Isto não significa, claro, que o Ant necessite do Tomcat, nem que seja utilizado apenas para desenvolvimento de aplicações web. Usamos como exemplos aplicações web no Tomcat para demonstrar como o Ant pode ser útil em situações específicas, e como ele é capaz de se integrar a outras tecnologias Java.

Baixando e instalando o Ant

Neste artigo, iremos partir do uso do Ant pela linha de comando. O quadro “Ant e IDEs” fala sobre o suporte ao Ant nos IDEs livres Eclipse e NetBeans; entretanto todos os exemplos deste artigo pressupõem o uso do Ant pela linha de comando. Por isso será necessária familiaridade com a configuração do path de comandos do seu sistema operacional. É preciso também que o JDK 1.4 ou superior já esteja configurado para uso pela linha de comando.

É simples obter e instalar o Ant. Basta visitar a página de download de distribuições binárias (Download| Binary Distributions) em ant.apache.org, ou então ir diretamente a ant.apache.org/bindownload.cgi. A página irá selecionar automaticamente um dos espelhos (mirrors) que contenham o software e estejam geograficamente mais próximos do usuário, baseado no seu endereço IP. Baixe o arquivo apache-ant-x.y.z-bin.zip onde x.y.z é o número da versão. No momento da escrita deste artigo, a versão mais recente era a 1.6.5, portanto o download seria apache-ant-1.6.5-bin.zip.

Usuários de algumas distribuições do Linux, em especial o Fedora Core 2 ou superior, já poderão encontrar o Ant como componente padrão dos seus sistemas. Embora seja possível utilizar esta instalação do Ant para executar os exemplos deste artigo, ela é baseada no compilador Java nativo GCJ, e não no JDK da Sun. Então poderá haver problemas com aplicações que necessitem de recursos do Java ainda não implementados pelo GCJ e pelo Projeto GNU Classpath (que fornece a biblioteca de classes do Java SE para o GCJ).

Feito o download, descompacte o arquivo zip em uma pasta qualquer, mas preservando a estrutura interna de diretórios do zip. Tome nota do nome desta pasta, e use preferencialmente um nome que não contenha espaços em branco ou acentos. O ideal é usar algo como C:\Java para usuários Windows ou /usr/local/java para usuários Linux. Dentro da pasta escolhida, a descompactação do arquivo zip irá criar a subpasta apache-ant-x.y.z.

O próximo passo é configurar a variável de ambiente ANT_HOME indicando o diretório de instalação do Ant e acrescentar a pasta bin ao path de comandos do sistema operacional. Usuários Windows podem usar:

 

set ANT_HOME=c:\java\apache-ant-1.6.5

set PATH=%PATH%;%ANT_HOME%\bin

 

Ou então utilizar o Painel de Controle para configurar as variáveis de ambiente de modo definitivo. Já usuários Linux fariam:

 

export ANT_HOME=/usr/local/java/apache-ant-1.6.5

export PATH=$PATH:$ANT_HOME/bin

 

Ou editariam os arquivos ~/.profile para incluir os comandos acima.

Usuários do Linux que já têm o Ant instalado, mas que preferem usar a sua própria instalação do Ant, devem cuidar de modificar também o arquivo /etc/ant.conf para indicar o valor correto de ANT_HOME, além de inserir a pasta da nova instalação do Ant no início do PATH, em vez de no final.

Em ambos os sistemas, para testar se a instalação do Ant está OK, digite o comando:

 

ant -version

Utilizando o Ant

O “buildfile” é o arquivo XML que fornece ao Ant as instruções que ele executa para a construção de uma aplicação Java. Por default seu nome é build.xml.

A seguir temos o que seria um exemplo mínimo de buildfile, que compila uma aplicação formada apenas pela classe Oi.java. Esta classe poderia ser qualquer aplicação do estilo “hello, world”, e seu fonte deve estar no mesmo diretório que o buildfile build.xml.

 

<project name="oi" default="compila">

  <target name="compila">

    <javac srcdir="." includes="Oi.java" />

  </target>

</project>

 

Para executar esse buildfile, basta digitar o comando ant, sem argumentos (supondo que o buildfile tenha o nome padrão build.xml). O resultado da execução será algo como:

 

Buildfile: build.xml

 

compila:

  [javac] Compiling 1 source file

 

BUILD SUCCESSFUL

Total time: 5 seconds

 

Este primeiro exemplo que é equivalente ao comando javac Oi.java, serve para ilustrar a estrutura de um buildfile, vista mais adiante. Na verdade, o Ant usa o próprio javac do JDK para compilar as classes; por isso é necessário ter um JDK instalado para usá-lo.

Usando outros compiladores

É possível configurar o Ant para usar outros compiladores Java, por exemplo o popular Jikes, tido por muitos como superior ao javac. Neste caso, o elemento <javac> teria que ser modificado para:

 

 <javac compiler=”jikes” srcdir="." includes="Oi.java" />

 

É claro, o Jikes teria que estar instalado e configurado em seu sistema (veja mais sobre o Jikes em jikes.sf.net).

Buildfiles com outros nomes

Caso o nome do buildfile não seja build.xml, basta indicar o nome do arquivo com a opção -f do comando ant, por exemplo:

 

ant -f teste.xml

Alvos e dependências

Em buildfiles contendo vários targets ou alvos (por exemplo, um alvo para compilar e outro para executar testes de unidade), o argumento do comando ant indica os nomes dos alvos a serem executados. Por exemplo:

 

ant compila

 

Os alvos, que definem conjuntos de atividades, serão executados na ordem especificada na linha de comando – a não ser que dependências entre os alvos obriguem algum alvo a ser executado antes.

Um único buildfile pode conter instruções para executar vários alvos mais ou menos independentes entre si, e o desenvolvedor pode optar por executar apenas os alvos desejados. De outro modo, o desenvolvedor seria obrigado a lidar com diversos buildfiles, um para cada tarefa, exatamente como ocorre quando são utilizados arquivos .bat do Windows ou scripts shell do Unix.

Saída

A quantidade de detalhes na saída do Ant pode ser alterada pelas opções -q (quiet, menos detalhes) e -v (verbose, mais detalhes). Já a opção -l arquivo permite indicar um nome de arquivo que receberá todas as mensagens, em vez de exibi-las no console.

É claro, pode-se combinar várias opções e argumentos na mesma linha de comando, por exemplo:

 

ant -q -f teste.xml compila

 

Este comando executa o alvo compila dentro do buildfile teste.xml, exibindo poucas informações sobre a execução do arquivo.

Estrutura de um buildfile

Um buildfile do Ant é formado por uma hierarquia onde a raiz é um único elemento <project>, que contém um ou mais elementos "

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?