ANT: Ferramenta de build

1.1 Objectivo

Automatizar várias tarefas típicas associadas ao desenvolvimento de software: compilação, distribuição, instalação e limpeza.

1.2 Características do Ant

O Ant é uma ferramenta de open source para automatizar o processo de construção de aplicações, semelhante ao make.

O processo de construção é definido num ficheiro de construção (build file) em formato XML, evitando os problemas inerentes às makefiles.

As operações que é possível executar como parte do processo de construção estão implementadas em Java, sendo facilmente extensível e possibilitando a introdução de novas operações sempre que necessário. Esta característica leva a que haja uma fraca dependência do sistema operativo em uso, visto que tudo é executado através da máquina virtual Java.

2.1 Projecto (Project)

Cada ficheiro de construção contém um único projecto, que define o processo de construção.

Um projecto (project) define um ou mais alvos (targets) que executam tarefas (tasks), parametrizadas por propriedades (properties).

O projecto permite ainda a definição do seu nome; o alvo de omissão, quando nenhum é estipulado na invocação do Ant; e o directório base, a utilizar sempre que houver referências a caminhos relativos.

Todas as tarefas definidas fora de um alvo são associadas a um alvo implícito invocado sempre como parte da inicialização do projecto.

2.2 Alvos (Targets)

Num projecto podem definir-se um ou mais alvos. Cada alvo é um contentor de tarefas que cooperam para realizar parte do processo de construção.

Um alvo pode definir dependências em relação a outros alvos que devem ser executados antes, sendo a ordem por que são definidas as dependências a seguida durante a execução (excepto se houver outras dependências). Convém notar que cada alvo apenas é executado a primeira vez, mesmo que seja referido em vários pontos do grafo de dependências.

É ainda possível condicionar a execução de um alvo à existência (ou não) de propriedades definidas.

2.3 Tarefas (Tasks)

Uma tarefa (task) é um procedimento, tipicamente executado dentro de um alvo. Cada um tem diversos atributos específicos, que funcionam como argumentos para a sua execução.

O Ant fornece um conjunto de tarefas pré-definidas que satisfazem as necessidades de grande parte dos processos de construção. Existe também a possibilidade de estender o Ant com novas tarefas.

2.4 Propriedades (properties)

Uma propriedade (property) é um par nome, valor. Uma vez definida, uma propriedade não pode ser modificada, excepto de forma temporária na execução da tarefa antcall.

Sempre que se refere o nome de uma propriedade em texto, este é substituido pelo valor que lhe está associado.

3.1 Execução do Ant

O Ant é executado através do comando ant e por omissão procura um ficheiro de construção chamado build.xml. Este comportamento pode ser alterado através do uso da opção -f seguida do nome do ficheiro de construção que se pretende utilizar.

 $ ant

 $ ant -f another-build.xml

Este vídeo apresenta o uso do Ant a partir da linha de comandos para executar um projecto exemplo.

 $ ant A

 $ ant A B C

 $ ant -p

3.2 Definição de propriedades

Uma propriedade define-se utilizando a tarefa pré-definida <property> e os atributos name e value.

 <property name="greeting" value="Good day!"/>

 <property name="relative-filename" location="xpto.txt"/>

 # a comment
 name1=value1
 name2=value2

 <property file="build.properties"/>

 $ ant -Dname1=value1 -Dname2=value2 target

3.3 Definição de um alvo

Um alvo define-se através da etiqueta <target>, podendo incluir ou não tarefas a executar no seu corpo:

 <target name="A"/>
 <target name="B">
 ...
 </target>

 <target name="A"/> 
 <target name="B" depends="A"/> 
 <target name="C" depends="B"/> 
 <target name="D" depends="C,B,A"/>
 
 ...

 $ ant D

 <target name="A" if="property.1"/>

 ...

 $ ant A

 $ ant -Dproperty.1=anything A

 <target name="A" if="property.1"/>

 ...

 <target name="B" depends="A" unless="property.2"> 

 ...

 </target>

 $ ant B

 $ ant -Dproperty.1=avalue B

 $ ant -D property.2=something B

 $ ant -Dproperty.1=avalue -Dproperty.2=anothervalue B 

3.4 Definição de um projecto

Um projecto define-se recorrendo à etiqueta XML <project>. Esta pode ainda ser configurada com qualquer dos seguintes atributos: name (nome do projecto), default (alvo de omissão) e/ou basedir (directório de omissão):

 <project name="MyProject" default="build" basedir=".">

   ...

 </project>

Por omissão, o Ant procura a definição do projecto num ficheiro de construção chamado build.xml, no entanto é possível dar-lhe qualquer outro nome, bastando para tal invocar o Ant com a opção -f seguida do nome do ficheiro de construção.

 $ ant -f another-build-file.xml

3.5 Uso de propriedades

Para se utilizar o valor de uma propriedade num texto deve usar-se a notação ${nome}. Por exemplo, se a propriedade dir tiver o valor c:/proj, então ${dir}/classes é substituído por c:/proj/classes.

4.1 Exemplo completo de ficheiro de construção: build.xml

 <project name="MyProject" default="run" basedir=".">

     <description>simple example build file</description>

     <property name="src.dir" location="src"/>
     <property name="build.dir" location="build"/>
     <property name="inputFile" location="etc\input_file.txt"/>
     <property name="outputFile" location="etc\output_file.txt"/>

     <property name="run.mainclass" value="example.OrderPropertyFile"/>
     <property name="run.args" value="${inputFile} ${outputFile}"/>

     <target name="init">
         <mkdir dir="${build.dir}"/>
     </target>

     <target name="clean" description="Delete the build directory" >
         <delete dir="${build.dir}"/>
     </target>

     <target name="compile" depends="init" description="Compiles the source code" >
         <javac srcdir="${src.dir}" destdir="${build.dir}"/>
     </target>

     <target name="run" depends="compile" description="Runs the program" >
         <java classname="${run.mainclass}" fork="true">
             <arg line="${run.args}"/>
             <classpath>
                 <pathelement location="${build.dir}"/>
             </classpath>
         </java>
     </target>

     <target name="show" description="Shows property values" >
         <echo message="src.dir = ${src.dir}"/>
         <echo message="build.dir = ${build.dir}"/>
         <echo message="run.mainclass = ${run.mainclass}"/>
         <echo message="run.args = ${run.args}"/>
     </target>

 </project>

• ant init - cria os directórios temporários
• ant clean - limpa os directórios temporários
• ant compile - depende de init, e compila o código do programa
• ant run - depende de compile, que depende de init, e executa o programa compilado
• ant show - mostra o valor das propriedades utilizadas e que podem ser parametrizadas

A definição de propriedades na linha de comandos permite alterar o comportamento observado, sem alterar o ficheiro de construção.

• ant -Drun.args=xpto show - modifica o valor de uma propriedade na linha de comando e mostra o valor das propriedades utilizadas

4.2 Aplicação de exemplo

A aplicação JavaPares é utilizada nos vídeos explicativos como exemplo de uma aplicação de consola e pode ser utilizada para exercitar o uso do Ant. Os vídeos explicativos mostram uma versão antiga desta aplicação.