Ant – Integración con IDE Eclipse

Ant, la popular herramienta de construcción de proyectos desarrollada por la Apache Software Foundation, esta nativamente integrada en el IDE Eclipse como plug-in. Esto nos puede permitir un cómodo desarrollo ya que podemos añadirle a nuestros proyectos scripts programados para Ant y hacer que funcionen como un constructor de proyecto realizando tareas como el empaquetamiento de archivos compilados en tarros (.jar), generar la documentación de código fuente, actualización de otros proyectos que necesitan estar en sincronía, etc. Podemos ordenar la ejecución de estos scripts manualmente o en forma automática junto a eventos del IDE, en si lo importante es decir que podemos usar Ant desde el interior del propio IDE.

En este tutorial para observar como funciona la integración de Ant con Eclipse, crearemos un simple proyecto en el IDE y luego un simple script de Ant que será capaz de ordenar la compilación y el empaquetamiento de los archivos compilados en un tarro .jar. Veremos como ejecutar manualmente dicho script, también como configurar el script junto al proyecto para que se ejecute automáticamente en ciertos eventos, y como exportar nuestro proyecto con Ant para obtener un script generado automáticamente por el IDE.

Requisitos:

  • Tener instalado el JDK (Java Development Kit): son las herramientas de desarrollo junto al entorno de ejecución. Hasta la fecha actual 2/05/2011 el último JDK disponible es el JSE 6.0 – Update 25.
  • Tener instalado el IDE Eclipse. Yo estoy usando en este momento Eclipse Helios (Service Release 1) en mi PC.
  • Conocimientos básicos de Java, Eclipse y Ant.

Creación de un proyecto


Antes que nada, crearemos un  proyecto de nombre: ProyectoAnt. En el proyecto crearemos un paquete de nombre: com.ejemplo, y dentro de este crearemos una clase de nombre: MiClase con un método main.

Hasta ahora el IDE se vería algo así:

En el método main de la clase agregamos alguna operación simple, por ejemplo:

...
System.out.println("Probando Ant y Eclipse!");
...

Puede ser cualquier cosa, es solo para que la clase haga algo al ejecutarse. Ejecutamos el proyecto, lo que nos recordara guardar antes de ejecutar, y se vera en la consola del IDE el resultado.

A continuación veremos la flexibilidad que nos proporciona el IDE para trabajar con Ant.

Creación de un constructor Ant


Para crear un constructor Ant, tenemos que crear un script XML (de extensión .xml) al cual típicamente y convenientemente se le nombra como build.xml. Aunque podemos ponerle otro nombre, es de buena practica usar este, además de que el IDE Eclipse tiene un editor Ant interno que por defecto esta asociado únicamente con archivos que se llamen build.xml. Se puede crear otra asociación de archivos también, pero por el momento para que reconozca nuestro archivo .xml como script de Ant le llamaremos build.xml.

Los pasos a seguir:

1- En “Project Explorer” seleccionamos nuestro proyecto, hacemos click derecho y en las opciones seleccionamos “New” -> “File“.

2- En la nueva ventana que veremos, donde dice “File Name:” introducimos el nombre del archivo que será “build.xml” y terminamos en “Finish“.

3- Ahora veremos que se ah creado un archivo build.xml el cual esta vacio y podemos editarlo desde el propio IDE, le agregamos el código XML que se ve a continuación y guardamos los cambios.

<?xml version="1.0" encoding="UTF-8"?>
<project name="ProyectoAnt" default="main">

	<target name="init">
		<tstamp />
		<property name="name" value="Prueba de Ant" />
		<property name="version" value="1.0.0" />
	</target>

	<target name="main" depends="init, compila, empaqueta" description="Compila y empaqueta">
		<echo message="Compilando y creando el archivo .jar" />
	</target>

	<target name="compila" description="Compila">
		<javac srcdir="src/com/ejemplo" destdir="bin/com/ejemplo" />
	</target>

	<target name="empaqueta" depends="init" description="Empaqueta">
		<jar jarfile="${name} v${version}.jar" basedir="bin" index="no" compress="yes">
			<manifest>
				<attribute name="Built-By" value="${user.name}" />
				<attribute name="Specification-Title" value="${name}" />
				<attribute name="Specification-Version" value="${version}" />
				<attribute name="Main-Class" value="com.ejemplo.MiClase" />
			</manifest>
		</jar>
	</target>

</project>

En la pestaña “Package Explorer” vemos listado nuestro archivo build.xml, podemos acceder a el y modificarlo cuando queramos, incluso el editor Ant del IDE ofrece coloreo, corrección, asistente de código, etc. para la sintaxis de XML, por lo que no necesitamos un editor externo.

Nota: Como sabemos no todo archivo .xml es necesariamente un script de Ant, de todas formas no ocurriria nada malo si se ejecutara accidentalmente con Ant un archivo .xml ajeno.

En la pestaña “Outline” podemos ver la estructura de nuestro XML, sus targets (objetivos) y properties (propiedades).

El archivo build.xml que hemos creado es muy simple, tiene cuatro targets que pueden invocarse:

init: lo único que hace es definir algunas propiedades que pueden ser usadas por otros targets.

main: este es el target principal y predeterminado, seria una construcción completa, se compila y luego empaqueta.

compila: se compilan las clases que se encuentran en el directorio src/com/ejemplo y se guardan en el directorio bin/com/ejemplo.

empaqueta: se empaqueta en un archivo .jar todo el contenido del directorio bin. Se especifica un archivo de manifiesto con algunas propiedades, la mas importante es Main-Class ya que esta permite al .jar ser autoejecutable.

Nota: en Windows la ejecución con doble-click del archivo .jar generado no funcionara porque la asociación de archivos .jar como ejecutables se realiza típicamente con javaw.exe el cual es el lanzador de aplicaciones gráficas, entonces se oculta la consola del sistema que seria la salida estándar. Para probar el archivo .jar desde afuera del IDE, usar java -jar desde la línea de comandos.

Configurar Ant

La configuración con respecto a Ant y su editor se puede encontrar en las preferencias del IDE. Si estamos interesados en modificar algo tenemos que ir al menú “Window” -> “Preferences” y en la ventana de preferencias nos dirigimos a la sección “Ant“.

Lo que tenemos aquí es la configuración general de Ant, y en las sub-secciones podremos configurar aspectos del editor Ant como el asistente de código, plantillas, etc.

Si queremos que el editor Ant reconozca otros nombres o cualquier archivo de extensión .xml como scripts de Ant necesitamos otra asociación de archivos para el editor. Esto se configura en esta misma ventana de preferencias pero en la sección “General” -> “Editors” -> “File Associations“.

Por ejemplo si quisiéramos que todo archivo de extensión .xml sea reconocido, en el primer cuadro de “File Types:” utilizamos “Add…” y agregamos a la lista un nuevo tipo de archivo llamado “*.xml”, entonces debajo en el cuadro de “Associated Editors:” aparecerán varias opciones de las que seleccionamos “Ant Editor” y finalmente asociamos  con “Add…“.

Ejecución manual del constructor Ant (build.xml)


En principio para ejecutar rápidamente el build.xml, lo seleccionamos con click derecho en la pestaña “Package Explorer”  y vamos a “Run as” -> “1 Ant Build“.

De esta forma estaremos ejecutando bajo configuración predeterminada, por lo que el target main del script ah sido invocado y se han compilado y empaquetado las clases en un .jar llamado “Prueba de Ant v1.0.0.jar” en el directorio raíz de nuestro proyecto, incluso en el “Package Explorer” si actualizamos apretando F5 aparecerá en la lista. En la consola del IDE se vera la salida de algunos datos.

Configurar la ejecución

También podemos configurar como será la ejecución del build.xml antes de ejecutarlo. Para esto tenemos que seguir los mismos pasos anteriores, solo que esta ves seleccionaremos la opción “Run as” ->”2 Ant Build…“.

Veremos la siguiente ventana:

La pestaña visible por defecto es “Targets“, el target predeterminado es main. Aquí podemos seleccionar que targets del script queremos ejecutar, pueden ser varios e incluso podemos ordenarlos. Por ejemplo si dejamos seleccionado únicamente el target compila y hacemos click en “Run” estaremos ejecutando el build.xml de forma personalizada y el resultado será que solo se compilaran los archivos fuente.

En la configuración se pueden modificar varias cosas, y es que podemos sacar provecho de Ant tanto desde el interior del IDE como desde afuera, por ejemplo podemos pasarle argumentos para la ejecución, esto lo podemos ver en la pestaña “Main“.

Luego de una ejecución personalizada, la configuración queda guardada como predeterminada, por lo que si volvemos a ejecutar nuestro build.xml de la forma rápida en “Run as” ->”1 Ant Build” se ejecutara la ultima configuración utilizada.

Varias configuraciones para un constructor Ant

Anteriormente vimos que se puede configurar la ejecución de nuestro build.xml antes de ejecutarlo, y esta queda guardada como predeterminada para la próxima vez. Ahora prestemos atención en la barra de herramientas, tenemos un historial de configuraciones de ejecución usadas junto a otras opciones:

Desde “1 ProyectoAnt Build.xml” podemos ejecutar bajo configuración predeterminada. De hecho es lo mismo que seleccionar “Run as” ->”1 Ant Build” desde la pestaña “Package Explorer“, que a su ves es lo mismo que hacerlo desde aquí mismo.

Una ventaja es que es más cómodo trabajar desde aquí que desde el “Package Explorer“.

Veamos la opción “External Tools Configurations…“, desde  esta podemos administrar, crear y ejecutar las configuraciones de ejecución guardadas. Por el momento la única configuración guardada es la predeterminada.

Podemos crear y guardar varias configuraciones de ejecución para un mismo build.xml. Para comprobarlo crearemos y guardaremos tres configuraciones diferentes: la primera ejecutara el target main, la segunda el target compila, y la tercera el target empaqueta. Los pasos son:

1- La primera configuración será la predeterminada que tenemos actualmente, pero le cambiaremos el nombre para poder tener todo mas organizado así que donde dice “Name:” modificamos “ProyectoAnt build.xml” por “ProyectoAnt predeterminado build.xml“, luego vamos a la pestaña “Targets“.

2- En la pestaña “Targets” nos aseguramos que este seleccionado el target main y luego guardamos los cambios con “Apply“.

3- Ahora que tenemos bien definida la configuración predeterminada, para crear las otras dos que faltan, simplemente clonamos esta dos veces haciendo click derecho en “ProyectoAnt predeterminado build.xml” seleccionando “Duplicate“. Lo hacemos dos veces y así tendremos dos copias del original.

4- Lo único que tenemos que hacer con estas dos copias es seguir los mismos pasos que hicimos para el original. En el segundo le cambiamos el nombre por “ProyectoAnt solo compila build.xml” y en los targets seleccionamos únicamente compila. En el tercero le le cambiamos el nombre por “ProyectoAnt solo empaqueta build.xml” y en los targets seleccionamos únicamente empaqueta. Usar “Apply” para ir guardando los cambios.

Se puede ejecutar cualquiera de estas configuraciones creadas haciendo doble click sobre ellas o seleccionando “Run“. En el historial de configuración de ejecuciones utilizadas siempre aparecerán primero las ejecutadas mas recientes. Sin embargo podemos forzar el orden en el historial si especificamos los favoritos en “Organize Favorites“.

Utilizando Ant View

Otra de las facilidades que nos da el IDE Eclipse es la pestaña “Ant View“, en la cual podemos tener en forma aislada y practica nuestros scripts de Ant. Esta pestaña no es visible por defecto, se puede activar seleccionando en el menú “Window” -> “Show View” -> “Ant“. En principio la pestaña esta vacía, somos nosotros los que tenemos que cargarle los scripts Ant que estemos interesados. Para agregar uno a la lista, en el menú de la pestaña seleccionamos el botón    y se nos abre una ventana donde seleccionamos el build.xml de nuestro proyecto, aceptamos en “Ok“. También tenemos el botón , pero este es para realizar una busqueda compleja en base a un paterno, algo ideal en caso de que tuviéramos muchos scripts de Ant y solo estuviéramos interesados en alguno especifico.

Ahora podemos ver el build.xml perteneciente a  nuestro proyecto ProyectoAnt en la pestaña “Ant View“, también se puede apreciar su correspondiente estructura de targets, properties y etc.

Desde aquí podemos también ejecutarlo u abrirlo para modificarlo.

Ejecución automática del constructor Ant (build.xml) como constructor de proyecto


Podemos especificar nuestro script Ant como constructor de proyecto. Esto es muy útil ya que podemos combinar nuestras tareas, ejecutándolas antes o después, con respecto a las tareas llevadas a cabo por el constructor interno del IDE Eclipse. Seguiremos utilizando el mismo build.xml creado anteriormente. Los pasos son:

1- En el “Package Explorer” hacemos click derecho sobre nuestro proyecto y seleccionamos “Properties“.

2- Se nos abrirá la ventana de propiedades de nuestro proyecto y seleccionamos la sección “Builders“. Aquí estaremos viendo los constructores para nuestro proyecto, por el momento el único listado será el constructor interno del IDE. Agregaremos nuestro constructor Ant, que ya lo tenemos echo, a la lista seleccionando “New“.

3- En una nueva ventana que veremos seleccionamos “Ant Builder” y luego “Ok“.

4- Finalmente hemos llegado a la configuración de la ejecución de nuestro constructor Ant para la construcción del proyecto. La ventana que estamos viendo es muy similar a la ventana de “External Tools Configurations…” donde podíamos administrar diversas configuraciones para un solo build.xml. Desde a partir de aquí, en la pestaña “Main” comienza la configuración:

a.  Especificamos un nombre para el constructor, en donde dice “Name:” introducimos “Mi Constructor”, luego en “Build file:” especificamos la ruta del script build.xml que podemos buscarla rápidamente con el botón “Browse Workspace…” al lado, mas abajo en “Base directory:” especificamos el directorio raíz de nuestro proyecto que podemos buscarlo rápidamente con el botón “Browse Workspace…” al lado. Luego de todo esto seleccionamos la pestaña “Refresh“.

b. Por defecto los constructores de proyecto no actualizan luego de finalizar. Para poder estar al tanto de lo que sucede en nuestro IDE, seleccionaremos la casilla “Refresh resources upon completion“. Y luego para ser mas específicos, seleccionaremos la opción “The project containing the selected resource” para que se actualicen solo los recursos relacionados a nuestro constructor Ant, esto ultimo lo hacemos mas que nada por motivos de eficiencia. Pasamos a la siguiente pestaña “Targets“.

c- Nos corresponde decidir bajo que eventos del IDE queremos que nuestro constructor sea ejecutado y que targets de este serán ejecutados. Los eventos posibles son:

After a “Clean”: sucede luego de que ordenamos una limpieza con la opción “Clean“.

Manual Build: sucede cuando ordenamos la construcción del proyecto.

Auto Build: sucede en forma automática, si esta activada la opcion de “Build Automatically“. Por ejemplo se ejecuta la construcción del proyecto  luego de guardar cambios. Esta opción puede afectar el rendimiento.

During a “Clean”: sucede mientras se realiza una limpieza ordenada con la opción “Clean“.

Los eventos activadas por defecto son los dos primeros, y el target seleccionado es el main de nuestro build.xml por lo que dirá “<default target selected>“.

Como el constructor interno del IDE realiza la compilación, y nuestro build.xml también, seleccionaremos para cada evento activado (After a “Clean” y Manual Build) solo el target empaqueta para que no se repita dos veces la compilación. Esto lo podemos hacer en el botón “Set Targets…” para cada evento, se nos abre una pequeña ventana en la que seleccionamos únicamente empaqueta y guardamos con “Ok“.

d- La configuración esta terminada. Guardamos todos los cambios en “Apply” y terminamos con “Ok“.

En la ventana de propiedades de nuestro proyecto podemos ver al constructor interno del IDE junto a nuestro constructor Ant, los dos activados. El orden en el que se encuentran listados determina el orden de ejecución, lo cual se puede modificar con los botones “Up” y “Down“. Así como se pueden agregar constructores también se pueden remover, excepto que no podemos remover el constructor interno del IDE aunque lo que si podemos hacerle es desactivarlo. Esto ultimo no es recomendable ya que el constructor interno esta vinculado a otras tareas importantes.

Regresamos al espacio de trabajo con “Ok“.

Ya podemos probar el funcionamiento automático de nuestro constructor Ant como constructor de proyecto. Realizamos una limpieza de nuestro proyecto seleccionando en el menú “Poject” -> “Clean“, y luego veremos en la consola del IDE una salida de datos que nos demuestra que se ah ejecutado nuestro build.xml. Lo mismo debería de suceder si hacemos algún pequeño cambio en algún archivo de nuestro proyecto para poder guardar los cambios y luego ordenamos la construcción en el menú “Project” -> “Build project“. En el directorio raíz de nuestro proyecto deberíamos de encontrar el tarro (Prueba de Ant v1.0.0.jar) con nuestras clases empaquetadas, incluso en el “Package Explorer” si actualizamos apretando F5 aparecerá en la lista.

Nota: los constructores de proyectos no sirven únicamente para trabajar con Java, por eso se pueden elegir otras herramientas externas además de Ant.

Exportar el proyecto con Ant


El IDE Eclipse nos permite exportar nuestro proyecto con Ant. Cuando exportamos, el IDE crea un constructor Ant predeterminado para un proyecto (o mas), al constructor le podemos agregar tareas desde otros .xml según nuestras necesidades y lo podemos ejecutar de cualquiera de las formas anteriormente vistas. Resulta muy conveniente poder mantener las propiedades de nuestro proyecto en sincronía con el constructor Ant al regenerarlo automáticamente con el IDE, entonces así como no tuvimos que escribirlo desde cero también se nos hace mucho mas fácil mantenerlo.

Antes de experimentar con esta opción lo primero que haremos será cambiarle el nombre a nuestro build.xml por build-custom.xml porque ahora trabajaremos con el build.xml generado por el IDE, para esto en el “Package Explorer” hacemos click derecho sobre el build.xml y seleccionamos “Refactor” -> “Rename“, luego le introducimos build-custom.xml. No hay que olvidarse de que si habíamos agregado ese build.xml como constructor de proyecto tenemos que quitarlo, así que en las propiedades del proyecto en la sección “Builders” desactivamos el script “Mi Constructor“.

Los pasos para exportar:

1- En la pestaña “Package Explorer” hacemos click derecho sobre nuestro proyecto y seleccionamos “Export…“.

2- En la nueva ventana tenemos que elegir como exportar el proyecto, seleccionamos “General” ->”Ant Buildfiles” y continuamos con “Next“.

3- Ahora se puede especificar en base a que proyectos se creara el constructor Ant y otras propiedades básicas como el nombre que tendrá. Como es un ejemplo muy simple solo estamos interesados en dejar seleccionado nuestro proyecto, lo demás queda como esta en forma predeterminada, terminamos con “Finish“.

Ahora veremos que el IDE genera un build.xml con funciones predeterminadas para nuestro proyecto. Si abrimos ese archivo para editarlo veremos en el código un comentario de advertencia que dice:

<!-- WARNING: Eclipse auto-generated file.
              Any modifications will be overwritten.
              To include a user specific buildfile here, simply create one in the same
              directory with the processing instruction 
              as the first entry and export the buildfile again. -->

Aquí explica que como este archivo es regenerado automáticamente por el IDE cualquier modificación que hagamos será sobrescrita y no quedara guardada. Por lo tanto si necesitamos agregar tareas propias tenemos que crearlas en otro script de Ant en el mismo directorio y su código tiene que comenzar con la línea “<?eclipse.ant.import?>“, luego exportamos nuevamente el proyecto con Ant y así el build.xml reconocerá nuestro script para importar.

Este constructor Ant generado por el IDE puede ser usado de la misma forma que uno creado por nosotros mismos, la diferencia es que no podemos modificar el build.xml, pero si podemos ejecutarlo manualmente o definirlo como constructor de proyecto para que se ejecute automáticamente de la misma forma como ya vimos antes con un simple script creado por mi.

Añadir tareas en un constructor Ant (build.xml) generado por el IDE


Como sabemos no podemos agregar tareas en el propio build.xml porque este es regenerado automáticamente. Así que crearemos un nuevo script de Ant con un target de ejemplo que representará la tarea que queremos agregar a la funcionalidad del build.xml generado por el IDE.

1- En nuestro proyecto creamos un nuevo archivo llamado build-user.xml. (Esto ya se explico antes)

2- Como el archivo no se llama build.xml el editor Ant del IDE no lo reconocerá como script de Ant, esto sucedería normalmente en forma predeterminada a menos que hubiéramos agregado otra asociación de archivos, como por ejemplo “*.xml”, para el editor Ant. En mi caso uso la configuración por defecto, por lo tanto no me sirve abrir el script normalmente con doble click y debo hacer algunos pasos extra para poder abrirlo con el editor Ant:

a. En la pestaña “Package Explorer” hacemos click derecho sobre nuestro script build-user.xml y seleccionamos “Open With” -> “Other“.

b- Tendremos una lista de editores, elegimos  “Ant Editor” y aceptamos con “Ok”.

3- Ahora que tenemos abierto build-user.xml con el editor Ant, introducimos el siguiente código y guardamos.

<?eclipse.ant.import?>
<project default="extra">

	<target name="extra" description="Una tarea extra definida por el usuario.">
		<echo message="Esta es una tarea extra!" />
	</target>

</project>

Notar que el script debe de comenzar con “<?eclipse.ant.import?>“.

4- Para que el build.xml del IDE importe nuestro script Ant necesitamos exportar el proyecto con Ant nuevamente de la misma forma que hicimos antes, esto regenerara el build.xml. Básicamente lo que sucederá es que el IDE buscara en el mismo directorio donde generara su build.xml otros archivos de extensión .xml que comiencen con la línea: “<?eclipse.ant.import?>“. Después de esto deberíamos de ver dentro del código del nuevo build.xml generado la línea: “<import file=”build-user.xml”/>“.

Y si por ejemplo ahora queremos ejecutar este build.xml de manera configurada (“Run as…“), tendremos para elegir todos los targets generados por el IDE en los cuales build es el predeterminado, y además tendremos los targets importados de nuestros scripts que en este caso lo único que había definido en mi build-user.xml era el target extra que lo único que hace es mostrar un mensaje en consola.


Más información:
* Eclipse documentation – Current Release
* The Apache Ant Project

Descargas:
* Eclipse IDE


, , , , , , , , , , ,

  1. #1 por oscar el marzo 9, 2012 - 9:05 am

    Hola,
    Estupendo tutorial, gracias.
    Estoy intentando crear un programa android desde un sketch ya creado de processing con ant pero no consigo meter el codigo de processing aunque ya ha creado el xml y demás.
    ¿Existe algun ejemplo o tutorial para amprender a crearlo?.
    Muchas gracias de antemano y un saludo.

  2. #3 por John Ortiz el marzo 11, 2012 - 12:54 am

    ¡Felicitaciones por este estúpendo trabajo! Introducción muy práctica.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: