Introduction à ant

Ant est un outil de build multi-plateforme fait en Java. Il permet d'automatiser diverses tâches répétitives que l'on fait durant le développement d'un projet. Compiler, copier/supprimer des fichiers, faire des checkout/update/commit sur un CVS, envoyer des mails, déployer l'application, exécuter notre code, etc… Il est fait en Java mais on peut également l'utiliser pour des projets qui utilisent d'autres langages. C'est gratuit et opensource (Apache License, Version 2.0)

Dans ce tutoriel nous allons apprendre les bases de ant :

• Concepts fondamentaux
• Installation
• Configuration
• Utilisation

• Connaitre les bases de Java
• Création d'un JAR
• Connaitre le XML

Allez sur le site de ant pour le télécharger.

http://ant.apache.org/bindownload.cgi

Téléchargez la dernière version stable. Ensuite extraire l’archive dans le répertoire que vous souhaitez installer ant.

Afin de configurer convenablement ant, il faut créer une variable d'environnement nommé ANT_HOME dont la valeur sera le chemin du répertoire d'installation de ant.

Il faut également modifier la variable d'environnement PATH pour y ajouter le chemin complet du répertoire bin se trouvant dans le répertoire d'installation.

Et il faut aussi créer la variable d'environnement JAVA_HOME qui pointe sur le répertoire du JDK. (si ce n'est pas déjà fait)

Pour tester si c'est fonctionnel, ouvrez un command prompt et tappez la ligne suivante :

ant

Vous devriez avoir le message suivante :

Buildfile: build.xml does not exist!
Build failed

La définition des tâches à exécuter - écrites en Java - se fait via un fichier de configuration XML. Ant fournit par défaut une bonne quantité de tâches. Il est également possible de créer ses propres tâches en plus de ceux que l'on trouve sur le net. Par exemple Tomcat qui est livré avec un ensemble de tâche ant.

Nous avons habituellement plusieurs tâches à faire. Donc il serait logique d'en faire un groupe, une sorte de “mega tâche” contenant d'autres tâches. Dans le monde de ant, une “mega-tâche” se nomme target.

Le fichier de configuration XML se nomme build.xml. Il se trouve habituellement à la racine de votre projet.

Voici un exemple basique de fichier XML qui compile et exécute un programme Java :

<?xml version="1.0" encoding="UTF-8"?>
<project name="monProjet" basedir=".">
 
	<target name="maMegaTache">
 
		<!-- création d'un répertoire pour la compilation -->
		<mkdir dir="build"/>
 
		<!-- compilation des sources Java -->
		<javac srcdir="src" destdir="build"/>
 
		<!-- exécution du code compilé -->
		<java classpath="build" classname="monpackage.ClassePrincipale" fork="true"/>
	</target>
 
</project>

Pour exécuter cette tâche, il suffit de tapper la ligne de commande suivante :

ant maMegaTache

Explication du fichier XML ci-dessus :

La racine du document, l'élement project, possède trois attributs :

• name : Le nom du projet.
• basedir : Le répertoire de base pour tout les path qui sont dans le fichier.
• default : Le target exécuté par défaut si on envoi aucun paramêtre à l'exécution de ant.

L'élément target possède cinq attributs :

• name : Le nom du target (obligatoire)
• depends : Une liste de nom de target séparé par des virgules. Ces target seront exécuter avant le target en question.
• if : Le target sera exécuté seulement si la propriété(valeur de l'attribut) est déclaré.
• unless : Le target sera exécuté seulement si la propriété(valeur de l'attribut) n'est pas déclaré.
• description : Petite description du target.

Note : l'attribute fork de la tâche java indique que le code sera exécuté dans nouvelle JVM (nouveau process), donc l'application sera indépendante de ant une fois lancé.

Mon exemple ci-dessus est assez léger mais ce n'est pas le cas avec un script complet qui est utilisé pour un gros projet. Il a souvent beaucoup de répétitions pour les nom de répertoire. Si on modifie la structure du projet pour n'importe quelle raison, il serait assez désagréable d'avoir à modifier tous les path dans le fichier de configuration. C'est pourquoi l'usage des propriétés est à adopter.

On déclare les propriétés de la manière suivante :

<property name="src.dir" value="src"/>

Dans ce cas ci je déclare la propriété src.dir qui représente le répertoire de source Java.

Pour utiliser les proprités dans le reste du fichier, il faut utiliser la syntaxe : ${nom.de.la.propriete}

Voici donc la nouvelle version notre fichier XML avec les propriétés :

<?xml version="1.0" encoding="UTF-8"?>
<project name="monProjet" basedir=".">
 
        <property name="src.dir" value="src"/>
        <property name="build.dir" value="build"/>
        <property name="main-class" value="monpackage.ClassePrincipale"/>
 
	<target name="maMegaTache">
 
		<!-- création d'un répertoire pour la compilation -->
		<mkdir dir="${build.dir}"/>
 
		<!-- compilation des sources Java -->
		<javac srcdir="${src.dir}" destdir="${build.dir}"/>
 
		<!-- exécution du code compilé -->
		<java classpath="${build.dir}" classname="${main-class}" fork="true"/>
	</target>
 
</project>

Il est possible d'extraire les propriétés et de les mettres dans un fichier externe.

Créer le fichier build.properties dans le racine de votre projet (même dossier que le build.xml)

#build.properties
src.dir=src
build.dir=build
dist.dir=dist
main-class=exemple.HelloWorld

voici le xml qui remplace la déclaration des propriétés :

<property file="build.properties"/>

Allons y avec un exemple un petit peu plus complexe. Supposons qu'on veuille distribuer son application sous la forme d'un JAR exécutable. Nous allons faire définir cinq target :

• clean : sont rôle est de supprimer les classes compilé et le JAR
• compile : sont rôle est de compiler le code source Java
• create-jar : sont rôle est de créer un JAR exécutable, il dépend du target clean et compile
• run : sont rôle est d'exécuter l'application
• build-and-run : sont rôle est de recompiler et exécuter l'application

Voici donc le fichier XML qui vient combler nos besoins : (les explications sont dans les commentaires du XML)

<?xml version="1.0" encoding="UTF-8"?>
<project name="monProjet" basedir="." default="compile">
 
        <!-- on inclu les propriétés -->
        <property file="build.properties"/>
 
        <!-- target qui supprime les classes compilé et le JAR -->
        <target name="clean">
                <delete dir="${build.dir}"/>
                <delete dir="${dist.dir}/${ant.project.name}.jar"/>
        </target>
 
        <!-- target qui compile le code Java dans le répertoire build -->
	<target name="compile">
 
		<!-- création d'un répertoire pour la compilation -->
		<mkdir dir="${build.dir}"/>
 
		<!-- compilation des sources Java -->
		<javac srcdir="${src.dir}" destdir="${build.dir}"/>
 
	</target>
 
 
        <!-- target qui crée le JAR -->
        <target name="create-jar" depends="clean,compile">
 
                <!-- création d'un répertoire pour le JAR -->
		<mkdir dir="${dist.dir}"/>
 
                <!-- création du JAR, dans mon exemple son nom sera "monProjet.jar" -->
                <jar destfile="${dist.dir}/${ant.project.name}.jar" basedir="${build.dir}">
			<manifest>
                                <!-- on indique la classe principale du JAR-->
				<attribute name="Main-Class" value="${main-class}"/>
			</manifest>
		</jar>	
 
	</target>
 
 
        <!-- exécution du JAR -->
        <target name="run">
                <java jar="${dist.dir}/${ant.project.name}.jar" fork="true"/>		
	</target> 
 
        <target name="build-and-run" depends="create-jar,run" />
 
</project>

Donc si je tappe les ligne de commande suivante :

• ant clean : Je supprime les classes compilé et le JAR
• ant compile : Je compile le code source de mon projet
• ant create-jar : Je supprime les classes compilé et le JAR, compile le code source de mon projet et je crée un JAR prêt à distribuer
• ant run : J'exécute le JAR
• ant build-and-run : Je supprime les classes compilé et le JAR, compile le code source de mon projet, je crée un JAR prêt à distribuer et j'exécute le JAR

Ant est un outil très puissant. Tout ceci n'est qu'un mince aperçu de sa puissance. Lorsqu'on commence à l'utiliser, on ne peut plus s'en passer…

Il est assez bien intégrer au IDE actuel. Par exemple NetBeans oblige l'utilisation de ant lorsque que l'on crée un projet. Il se créer son propre fichier build.xml par défaut mais peut le modifier à notre aise. Il permet également de mettre des raccourcis dans l'interface graphique qui exécute un target de notre script ant.

Un petit rappel pour ceux qui l'ont raté : la liste des tâche inclus avec ant par défaut

• Site officiel de ant
• Guide de l'utilisateur (en)