PDF de programación - Manual básico de ANT

Manual básico de ANT

De Wikilibros, la colección de libros de texto de contenido libre.

Apache Ant es una herramienta usada en programación (véase Fundamentos de programación) para la realización de tareas mecánicas y repetitivas,
normalmente durante la fase de compilación y construcción (build). Es similar a Make pero desarrollado en lenguaje Java y requiere la plataforma Java.

Esta herramienta, hecha en el lenguaje de programación Java, tiene la ventaja de no depender de las órdenes del shell de cada sistema operativo, sino que
se basa en archivos de configuración XML y clases Java para la realización de las distintas tareas, siendo idónea como solución multi­plataforma.

Contenido

1 Ejecución de Apache Ant

1.1 ¿Qué se necesita para ejecutar ANT?
1.2 Algunas consideraciones a tener en cuenta
1.3 Ejecución de ANT

2 Configuración

2.1 Estructura de un fichero build.xml
2.2 Ejemplo de buildfile
2.3 Ejemplo para una aplicación Hola Mundo

2.3.1 Fichero de ejemplo build.xml

3 Portabilidad
4 Referencias

4.1 Bibliografía

Ejecución de Apache Ant
¿Qué se necesita para ejecutar ANT?

Para utilizar ANT basta con disponer de una distribución binaria de ANT y tener instalado la versión 1.4 o superior del JDK. La distribución binaria
consiste en la siguiente estructura de directorios:

ant
+--- bin // contains launcher scripts
|
+--- lib // contains Ant jars plus necessary dependencies
|
+--- docs // contains documentation
| +--- ant2 // a brief description of ant2 requirements
| |
| +--- images // various logos for html documentation
| |
| +--- manual // Ant documentation (a must read ;-)
|
+--- etc // contains xsl goodies to:
// - create an enhanced report from xml output of various tasks.
// - migrate your build files and get rid of 'deprecated' warning
// - ... and more ;-)

De dichos directorios, sólo se necesitan bin y lib para ejecutar ANT.
Algunas consideraciones a tener en cuenta

Al ser una herramienta basada en XML, los archivos Ant deben ser escritos en XML.
La mayoría de las antiguas herramientas — las que se usan todos los días, como <javac>, <exec> y <java> — tienen malas configuraciones por
defecto, valores para opciones que no son coherentes con las tareas más recientes.
Cuando se expanden las propiedades en una cadena o un elemento de texto, las propiedades no definidas no son planteadas como error, sino que
se dejan como una referencia sin expandir (ej.: ${unassigned.property}).
No es un lenguaje para un flujo de trabajo general, y no debería ser usado como tal.

Ejecución de ANT

Para ejecutar ANT basta con escribir ant en la línea de comandos. Si se ha especificado la ejecución de un objetivo por defecto en la cabecera del
proyecto del fichero build.xml no es necesario el uso de ningún parámetro ya que, como acabamos de ver en el ejemplo anterior, se ejecutara este por
defecto. Para utilizar un buildfile diferente de build.xml hay que añadir el parámetro ­buildfile nombre_fichero, donde nombre_fichero es el buildfile que
se quiere utilizar:

ant -buildfile buildfile_alt.xml

Si se desea ejecutar uno o varios objetivos concretos, se debe añadir el nombre de este o estos objetivos en la línea de comandos vv:

ant clean

En este caso se ignorará el objetivo indicado en la cabecera del proyecto.

Configuración

Una vez obtenida la anterior distribución de ANT, se deben seguir los siguientes pasos:

­ Añadir el directorio "bin" al path. ­ Asignar a la variable de entorno "ANT_HOME" la ruta donde se ha instalado ANT. ­ Opcionalmente, asignar a la
variable de entorno "JAVA_HOME" la ruta donde se ha instalado el JDK.

Dependiendo del sistema operativo en el que nos encontremos tendremos los siguientes ejemplos de configuración:

Windows y OS/2
(Suponiendo que se ha instalado ANT en c:\ant\)

set ANT_HOME=c:\ant
set JAVA_HOME=c:\jdk1.2.2
set PATH=%PATH%;%ANT_HOME%\bin

Unix (bash)
(Suponiendo que se ha instalado ANT en /usr/local/ant)

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk­1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

Unix (csh)
setenv ANT_HOME /usr/local/ant
setenv JAVA_HOME /usr/local/jdk­1.2.2
set path=( $path $ANT_HOME/bin )
Estructura de un fichero build.xml

Los ficheros buildfiles de ANT están escritos en XML. Cada buildfile contiene un proyecto (project) y al menos un objetivo (target). Cada objetivo
puede contener varias tareas (task) que son fragmentos de código a ejecutar. Un proyecto, además, puede constar de diversas propiedades. Cada
propiedad consta de nombre y valor y son usadas para asignar valores a los atributos de los task.

La estructura de un fichero buildfile podría ser la siguiente:

buildfile
+--- project // proyecto del buildfile
+
+--- property_1
+--- property_2
+--- target_1 // objetivo_1
| |
| +--- task_1 // tarea 1 de target_1
|
+--- target_2 // objetivo_2
| |
| +--- task_1 // tarea 1 de target_2
| +--- task_2 // tarea 2 de target_2
|
+--- target_3 // objetivo_3
|
+--- task_1 // tarea 1 de target_3


Ejemplo de buildfile

A continuación se muestra un ejemplo de un archivo build.xml:

<project name="MyProject" default="dist" basedir=".">
<description>
simple example build file

</description>
<property name="src" location="src"/>
<property name="build" location="build"/>
<property name="dist" location="dist"/>
<target name="init">
<tstamp/>
<mkdir dir="${build}"/>
</target>
<target name="compile" depends="init" description="compile the source " >
<javac srcdir="${src}" destdir="${build}"/>
</target>
<target name="dist" depends="compile" description="generate the distribution" >
<mkdir dir="${dist}/lib"/>
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>
<target name="clean" description="clean up" >
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>
</project>

La primera línea se corresponde con el proyecto que compone el buildfile, en ella pueden aparecer los siguientes atributos:

- name = "MyProject": identifica el nombre del proyecto
- default = "dist": identifica el objetivo que se ejecuta por defecto, en caso de no especificarle uno en concreto.
- basedir = ".": directorio base sobre el que vamos a trabajar. En este ejemplo se trabajaría sobre el directorio actual.

A continuación aparecen un listado de propiedades, su declaración se compone del literal property y los atributos name para especificar el nombre y
location para asignarles un valor.

<property name="src" location="src"/>

Lo siguiente que aparece en el ejemplo son los objetivos. El primero de ellos es init:

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

Como se mencionó anteriormente, un objetivo esta compuesto por una o varias tareas, en este caso tenemos las tareas tstamp y mkdir, las cuales
muestran la fecha y crean el directorio descrito por la propiedad build respectivamente.

El siguiente objetivo que aparece es compile

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

En la declaración del objetivo podemos ver los siguiente atributos:

- name = "compile": identifica el nombre del objetivo
- depends = "init": identifica el objetivo que se debe ejecutar antes de lanzarse el actual.
En este caso se debe ejecutar previamente el objetivo init (mostrar la fecha del sistema y crear un directorio) antes de ejecutar este objetivo.
- description = "compile the source": breve descripción de lo que hace el objetivo.

El cuerpo del objetivo está formado por la tarea javac, que toma los ficheros fuente ubicados en la ruta indicada por el atributo srcdir y los compila en
destdir.

El siguiente objetivo que compone el buildfile es dist.

<target name="dist" depends="compile" description="generate the distribution" >
<mkdir dir="${dist}/lib"/>
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>

En este caso, dist depende del objetivo compile para ejecutarse, luego, antes de lanzar sus tareas se debe haber ejecutado compile. En este objetivo
aparece la tarea mkdir descrita anteriormente y jar, esta tarea construye un jar con el nombre MyProject concatenado con la fecha del sistema
(DSTAMP) a partir de los compilados en el directorio indicado por la propiedad build.

Por ultimo tenemos el objetivo clean

<target name="clean" description="clean up" >
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>

Compuesto por 2 tareas delete. Simplemente borra los directorios temporales necesarios para la creación del jar.

Si repasamos la cabecera del proyecto, vemos que por defecto llama al objetivo dist, el cual depende de compile y este a su vez de init, por lo que el
orden lógico de ejecución de este build.xml es:

Ejecutar objetivo init
- mostrar fecha de sistema
- crear directorio build
Ejecutar objetivo compile
- compilar fuentes de src y guardarlos en build
Ejecutar objetivo dist
- crear directorio lib
- crear jar a partir de los compilados

El objetivo clean no depende del resto y tampoco se especifica en la cabecera del proyecto, por lo que se debe referenciar de forma explicita en la línea
de comandos para que se ejecute.

Otro ejemplo de build.xmlpuede ser el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<project name="projetWar" basedir="." default="checkstyle">

<property name="base.dir" value="../" />
<property name="baseTool.dir" value="../../outils/" />

<property name="src.dir" value="${base.dir}src" />
<property name="build.dir" value="${base.dir}webapp/WEB-INF/classes" />
<property name="doc" location="${base.dir}doc" />
<property name="lib" location="${base.dir}lib" />