|
|
Daniel Quirino Oliveira
Torne as chatas e repetitivas tarefas diárias de desenvolvimento de software automatizadas com Ant.
 Download do material relacionado ao tutorial
Cena típica: final do expediente e você louco para sair do escritório e encontrar com o pessoal no happy hour naquele barzinho. No entanto, você se lembra que ainda tem que fazer o build diário do sistema, mandar um email reportando os resultados para o gerente do projeto, além de fazer o check-in no CVS do novo build. Aí bate aquela dúvida: será que eu perco o happy hour ou jogo este papo todo de integração contínua para o alto, uma vez que você acha que isso tudo é uma balela que só serve para inglês ver.
Se você for um profissional responsável, mesmo que você ache que integração contínua é papo furado, você vai cumprir seu dever e perder o happy hour do escritório. No entanto, se você for um profissional mais antenado, você provavelmente irá usar o Ant, uma ferramenta desenvolvida pelo projeto Jakarta (http://jakarta.apache.org/ant) para a automatização de processos de construção (build), testes e distribuição (deploy) de aplicações para qualquer tipo de projeto Java, seja ele pequeno ou grande. Ou seja, precisou automatizar tarefas como compilação de projetos, montagem de .jar e criação de Javadoc (entre outras coisas), você precisa do Ant. E se você ainda não sabe como usar o Ant, mas está muito interessado em começar a aprendê-lo, então este artigo é para você.
Mas, o que é integração contínua mesmo?
Antes de continuar a falar sobre o Ant, é bom esclarecer o que vem a ser integração contínua. O termo "integração contínua" começou a ficar bastante conhecido com o boom da metodologia XP (embora suas práticas já existam há algum tempo). Basicamente, o processo de integração contínua visa, como diz o nome, manter o sistema integrado durante todo o seu desenvolvimento, evitando alguns probleminhas muito comuns quando se trabalha em desenvolvimento com equipes, como o surgimento de bugs que não são detectados em testes quando o sistema não está integrado. Para maiores informações sobre integração contínua, recomendo a leitura deste artigo: http://www.martinfowler.com/articles/continuousIntegration.html.
As maravilhas do Ant
Ant é capaz de automatizar as mais diversas tarefas que fazem parte do cotiadiano de desenvolvimento de software, como manipulação de diretórios, criar arquivos JAR/ZIP, a documentação da API do seu sistema e automatização de testes (além de outras mais avançadas, como manipulação de arquivos em sistemas de controle de versão, mas que não serão cobertas por este artigo). Também é possível também fazer o download de tasks complementares que fazem desde geração de código para integração de Java e C através de JNI até checagem de estilo de código. Mas, por este ser apenas uma introdução ao ANT, vamos fazer algo simples e que vai ser muito útil no dia-a-dia de muitos.
Mas como funciona?
Supondo que você já tenha feito o download do Ant no site do projeto Jakarta, o processo de instalação é simples e requer apenas 3 passos:
descompactar o arquivo baixado em qualquer diretório (por exemplo, "C:/Ant", no caso do Windows, ou "/usr/ant", caso você esteja usando algum tipo de Unix). Independente de onde você o descompactar, este diretório será chamado de ANT_HOME.
adicione uma variável de ambiente ao seu sistema operacional chamada ANT_HOME, cujo valor aponta para o diretório onde você descompactou o Ant.
adicione o caminho ANT_HOME/bin à variável de ambiente PATH.
E pronto. Abra o console e digite apenas "ant". Provavelmente você verá uma mensagem de erro, como a da figura abaixo.
E agora?
O erro acontece porque o ant procura um buildfile no diretório em que o comando está sendo executado. Então é hora de criar o nosso buildfile.
O buildfile é um arquivo xml que dita ao Ant todas as tarefas que ele vai executar. Para exemplificar, vamos considerar um pequeno projeto em que os fontes estão no diretório "src" e a documentação da API em "docs" (faça o download do pacote de exemplo deste artigo). O nosso script deverá se parecer com este:
<?xml version="1.0"?>
<project name="meuprojeto" default="build" basedir=".">
<property name="name" value="meuprojeto"/>
<property name="src" value="src"/>
<property name="docs" value="docs"/>
<property name="main" value="guj.MainClass"/>
<property name="tmp" value="tmp"/>
<property name="bin" value="bin"/>
<target name="compile">
<mkdir dir="\${tmp}"/>
<javac srcdir="\${src}" destdir="\${tmp}" debug="on" deprecation="on"/>
</target>
<target name="jar" depends="compile" description="cria um .jar contendo os .class do diretório temporário">
<mkdir dir="\${bin}"/>
<jar jarfile="\${bin}/\${name}.jar" basedir="\${tmp}"/>
</target>
<target name="javadoc" description="Gera os javadocs de todas as classes do pacote guj.*">
<javadoc sourcepath="\${src}" destdir="\${docs}" packagenames="guj.*"/>
</target>
<target name="clean" description="Remove arquivos temporários">
<delete dir="\${tmp}"/>
</target>
<target name="build" depends="compile,jar,javadoc,clean" />
<target name="run" depends="compile,jar,clean" description="inicia a aplicação">
<java classname="\${main}" classpath="\${bin}/\${name}.jar"/>
</target>
</project>
|
Explicando tudo...
Eis o nosso script. Ele compila os fontes, cria um JAR, gera a documentação da API, limpa todos os arquivos temporários e pode executar o nosso programinha.
Todo os passos da construção do seu projeto, que são descritas pelas diversas tags , devem estar aninhados dentro da tag . Esta tag é o ponto de entrada do nosso script e todo buildfile contém um , que, por sua vez, deve possuir ao menos uma operação padrão, denotada pelo atributo "default" (que é obrigatório). Além disso, é possível dar um nome ao projeto (atributo "name") e determinar qual o diretório base do projeto (atributo "basedir"). Embora estes dois últimos atributos não sejam obrigatórios, é sempre bom declará-los.
Já as tags funcionam como variáveis, cujos valores podem ser usados dentro de um projeto. No nosso caso, criamos propriedades que definem os diretórios onde estão os fontes do nosso projeto e onde a documentação do projeto e os "binários" serão gerados, além de definirmos qual é a classe principal do nosso projeto.
As tags definem um conjunto de instruções a serem executadas. Por exemplo, no nosso script, a operação "compile" (elemento cujo atributo name é igual a "compile") contém duas tarefas: uma que cria um diretório temporário e outra que compila nossos fontes e joga as classes neste diretório. Além disso, é possível determinar se uma operação vai depender de outra, dando como valor ao atributo "depends" o nome de uma outra operação definida no projeto (como é o caso da operação "jar", que depende da operação "compile"). Isso é muito importante para o caso da operação "jar" ser invocada, uma vez que ela vai executar a operação "compile" antes (isso se ela já não tiver sido executada). Para se executar uma operação em especial, você deve passar ao Ant um parâmetro com o nome da operação. Caso nenhum parâmetro seja passado, o Ant irá executar a operação padrão (no nosso caso, a operação padrão é a "build").
Construindo...
Agora só nos resta construir nosso projeto. Para isso, é só digitar "ant" no console e ver o resultado.
E isso é tudo, pessoal. Ant possui inúmeras outras tarefas que podem ser embutidas no seu script. A melhor forma de saber se a tarefa que você procura está disponível para o Ant é vendo a seção "Ant tasks" do manual do Ant (http://ant.apache.org/manual/index.html). Dúvidas, críticas, sugestões? Usem nosso fórum. Até mais.
|
|
|
