Prise en main d'Ant

Selim KEBIR

Le but principal de cet article est de faire découvrir Ant aux développeurs Java qui ne connaissent pas encore cet outil. Afin de dévoiler les principaux apports d'Ant, nous allons comparer la création d'un projet en ligne de commande classique avec la création du même projet avec Ant. ♪

- Titre : Prise en main d'Ant

- Auteur : Selim KEBIR

- Parution : 1 octobre 2008

- Licence :

Sommaire

- I. Introduction

- II. Création du projet par ligne de commande

- II-A. Compilation

- II-B. Création du fichier jar exécutable

- II-C. Exécution du projet

- III. Création du projet avec Ant

- III-A. La cible clean

- III-B. La cible compile

- III-C. La cible jar

- III-D. Exécution du projet

- III-E. Dépendances entre cibles

- III-F. Récapitulatif

- III-G. Amélioration du fichier build.xml

- IV. Comparaison entre build.xml et la ligne de commande

- V. Autres outils

- V-A. Maven

- VI. Liens utiles

- VII. Téléchargement de sources

- VIII. Conclusion

- IX. Remerciements

I - Introduction

Ant est un projet open source de la fondation Apache écrit en Java qui vise le développement d'un logiciel d'automatisation des opérations répétitives tout au long du cycle de développement logiciel. Il est téléchargeable à l'adresse suivante http://ant.apache.org.

Ant pourrait être comparé au célèbre outil make sous Unix. Il a été développé pour fournir un outil de construction indépendant de toute plate-forme. Ceci est particulièrement utile pour des projets développés sur et pour plusieurs systèmes ou pour migrer des projets d'un système vers un autre. Il est aussi très efficace pour de petits développements.

Ant repose sur un fichier de configuration XML qui décrit les différentes tâches qui devront être exécutées par l'outil. Ant fournit un certain nombre de tâches courantes qui sont codées sous forme de classes Java. Ces tâches sont donc indépendantes du système sur lequel elles seront exécutées. De plus, il est possible d'ajouter ces propres tâches en écrivant de nouvelles classes Java respectant certaines spécifications.

La popularité d'Ant augmente de jour en jour. Sa souplesse, sa puissance et sa simplicité en ont fait l'un des outils les plus populaires dans le monde de Java.

Les environnements de développement intégrés proposent souvent un outil de construction propriétaire qui son généralement moins souple et moins puissant que Ant. Ainsi des plug-ins ont été développés pour la majorité d'entre eux (JBuilder, Forte, Visual Age …) pour leur permettre d'utiliser Ant, devenu un standard de facto.

L'IDE Netbeans intègre Ant depuis sa version 4.0, il prévoit un fichier build.xml pour tous ses projets.

II - Création du projet par ligne de commande

Dans ce tutoriel, nous voulons séparer les sources des fichiers compilés, donc nos fichiers sources (.java) seront placés dans le répertoire src. Tous les fichiers (.class) générés doivent être placés dans le répertoire bin et enfin le fichier jar de notre projet ira dans le répertoire exe.

Nous avons utilisé la syntaxe de la ligne de commande de Windows. Sous Linux le md est remplacé par mkdir et l'antislash (\) par un simple slash (/). Les autres commandes devraient toutes marcher sans problème.

On aura donc l'arborescence suivante :

II-A - Compilation

On crée seulement le répertoire src. Voici la commande le permettant :

md src

La classe java suivante affiche « Hello world » dans la sortie standard :

HelloWorld.java

package org.sdf;

public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}

Vous devez mettre ce code dans un fichier nommé HelloWorld.java. Ce fichier doit se trouver dans le répertoire src/org/sdf. On aura donc ceci :

Maintenant nous allons essayer de compiler et exécuter notre projet.

md bin
javac -sourcepath src -d bin\ src\org\sdf\HelloWorld.java
java -cp bin org.sdf.HelloWorld

Qui va résulter en ceci :

Hello World.

Après la compilation du fichier source, on aura l'arborescence suivante :

II-B - Création du fichier jar exécutable

La création du fichier jar n'est pas très difficile. Mais le rendre exécutable nécessite plus d'une étape :

1. Création d'un fichier manifest contenant le nom de la class principale ;

2. Création du répertoire exe ;

3. Création du fichier jar.

Tout ceci peut être effectué en ligne de commande comme suit :

echo Main-Class: org.sdf.HelloWorld>MonManifest
md exe
jar cfm exe\HelloWorld.jar MonManifest -C bin .

Après l'exécution de ces trois lignes, on aura l'arborescence de fichiers suivante :

II-C - Exécution du projet

On pourra exécuter notre projet avec la ligne de commande :

java -jar exe\HelloWorld.jar

III - Création du projet avec Ant

Nous allons maintenant essayer de créer un fichier build.xml Ant. Pour notre projet, ce build.xml contiendra 4 cibles : clean, compile, jar et run.

III-A - La cible clean

Cette entrée permet de supprimer tous les fichiers générés lors de la compilation et de la création du fichier. En général, c’est une bonne habitude d'avoir une cible clean.

<target name="clean">
<delete dir="bin"/>
<delete dir="exe"/>
</target>

Notre cible clean est très simple, il appellera la tâche delete deux fois, une fois pour supprimer les fichiers class générés, et une autre pour supprimer le fichier jar.

III-B - La cible compile

Cette entrée permet de créer un répertoire nommé bin puis de compiler les fichiers sources du répertoire src, et de mettre les fichiers générés dans le répertoire bin.

<target name="compile">
<mkdir dir="bin"/>
<javac srcdir="src" destdir="bin"/>
</target>

La création du répertoire bin se fait avec la tâche mkdir. La compilation appelle la tâche javac tout simplement.

III-C - La cible jar

Cette entrée permet de créer un répertoire nommé exe et de créer le fichier jar exécutable de notre projet dans ce répertoire.

<target name="jar">
<mkdir dir="exe"/>
<jar destfile="exe/HelloWorld.jar" basedir="bin">
<manifest>
<attribute name="Main-Class" value="org.sdf.HelloWorld"/>
</manifest>
</jar>
</target>

La création du répertoire exe se fait avec la tâche mkdir. La création du fichier jar exécutable se fait avec la tâche jar. Le fichier manifest est créé très facilement avec l'élément manifest.

III-D - Exécution du projet

Cette entrée permet d'exécuter le fichier jar exécutable généré lors de l'étape précédente.

<target name="run">
<java jar="exe/HelloWorld.jar" fork="true"/>
</target>

La tâche java permet d'exécuter le fichier jar. Fork= « true » permet d'exécuter le projet dans une nouvelle machine virtuelle Java.

III-E - Dépendances entre cibles

L'exécution d'une cible (target) peut dépendre de l'exécution d'autres cibles. Dans notre exemple, la cible jar dépend de la cible compile. Il n'est pas logique de générer un fichier Jar sans que les sources soient compilés.

Ant offre un mécanisme de dépendance qui permet d'ordonner l'exécution des cibles du fichier build.xml. Ce mécanisme est implémenté avec l'attribut depends.

Exemple :

<target name="jar" depends="compile">
<mkdir dir="exe"/>
<jar destfile="exe/HelloWorld.jar" basedir="bin">
<manifest>
<attribute name="Main-Class" value="org.sdf.HelloWorld"/>
</manifest>
</jar>
</target>

L'exécution de cette cible requiert l'exécution de la cible compile. Ant se chargera de le faire. Si la cible compile dépend elle aussi d'une autre cible, alors Ant se chargera d'exécuter les dépendances récursivement.

III-F - Récapitulatif

Après avoir écrit les principales cibles de notre projet, nous allons maintenant construire notre fichier build.xml qui sera utilisé par Ant pour exécuter les différentes tâches. Le fichier build.xml doit avoir comme racine un élément appelé project. Cet élément peut avoir les attributs suivants :

Attribut

Description

Obligatoire

name

Le nom du projet

non

default

la cible par défaut à utiliser lorsqu'aucune cible n'est indiquée

non

basedir

le répertoire de base du projet

non

<project default="run">

<target name="clean">
<delete dir="bin"/>
<delete dir="exe"/>
</target>

<target name="compile" depends="clean">
<mkdir dir="bin"/>
<javac srcdir="src" destdir="bin"/>
</target>

<target name="jar" depends="compile">
<mkdir dir="exe"/>
<jar destfile="exe/HelloWorld.jar" basedir="bin">
<manifest>
<attribute name="Main-Class" value="org.sdf.HelloWorld"/>
</manifest>
</jar>
</target>

<target name="run" depends="jar">
<java jar="exe/HelloWorld.jar" fork="true"/>
</target>

</project>

Maintenant, on peut compiler, archiver et exécuter notre projet avec les commandes :

ant clean
ant compile
ant jar
ant run

Et puisque run dépend de jar qui dépend de compile qui dépend de clean, On peut faire tout simplement :

ant run

Ou mieux encore, puisque la cible par défaut du projet est run :

ant

III-G - Amélioration du fichier build.xml

Maintenant que nous avons notre fichier build.xml, on peut y effectuer quelques optimisations. On remarque qu'on a utilisé plusieurs fois les mêmes noms de répertoires. Un problème surviendrait si l'on voulait changer le répertoire où seront générés les fichiers compilés : il faudrait changer toutes les occurrences de bin dans le fichier.

Pour contourner ce problème, Ant offre le mécanisme de propriétés. Il s'agit de déclarer des propriétés qui ont des valeurs, et de récupérer leur valeur n'importe où dans notre fichier build.xml.

De plus, Ant nous offre la possibilité de garder une trace de l'exécution du fichier build.xml par l'emploi de la tâche echo. Ceci peut s'avérer très utile dans certains cas.

build.xml

<project default="run">

<property name="src.dir"     value="src"/>
<property name="bin.dir"   value="bin"/>
<property name="jar.dir" value="exe"/>
<property name="main-class"  value="org.sdf.HelloWorld"/>

<target name="clean">
<delete dir="${bin.dir}"/>
<delete dir="${jar.dir}"/>
<echo message="nettoyage termine"/>
</target>

<target name="compile" depends="clean">
<mkdir dir="${bin.dir}"/>
<javac srcdir="${src.dir}" destdir="${bin.dir}"/>
<echo message="compilation terminee"/>
</target>

<target name="jar" depends="compile">
<mkdir dir="${jar.dir}"/>
<jar destfile="${jar.dir}/sdf.jar" basedir="${bin.dir}">
<manifest>
<attribute name="Main-Class" value="${main-class}"/>
</manifest>
</jar>
<echo message="Creation du fichier Jar terminee"/>
</target>

<target name="run" depends="jar">
<java jar="${jar.dir}/sdf.jar" fork="true"/>
</target>

</project>

Maintenant, si on veut changer le répertoire où seront placés les fichiers compilés, il suffira de changer la valeur de la propriété bin.dir.

IV - Comparaison entre build.xml et la ligne de commande

Nous avons essayé d'établir un tableau de comparaison entre la compilation, l'archivage et l'exécution en ligne de commande et avec Ant. Ceci est résumé dans le tableau suivant :

Ligne de commande

build.xml

md bin
javac -sourcepath src -d bin\ src\org\sdf\HelloWorld.java

<target name=« compile »>
<mkdir dir=« bin »/>
<javac srcdir=« src » destdir=« bin »/> </target>

echo Main-Class: org.sdf.HelloWorld>MonManifest
md exe
jar cfm exe\HelloWorld.jar MonManifest -C bin .

<target name=« jar »>
<mkdir dir=« exe »/>
<jar destfile=« exe/HelloWorld.jar » basedir=« bin »>
<manifest>
<attribute name=« Main-Class » value=« org.sdf.HelloWorld »/>
</manifest>
</jar>
</target>

java -jar exe\HelloWorld.jar

<target name=« run »>
<java jar=« exe/HelloWorld.jar » fork=« true »/>
</target>

V - Autres outils

V-A - Maven

Apache Maven est un outil logiciel libre pour la gestion et l'automatisation de production des projets logiciels Java. L'objectif recherché est comparable au système Make sous Unix : produire un logiciel à partir de ses sources, en optimisant les tâches réalisées à cette fin et en garantissant le bon ordre de fabrication.

Il est semblable à l'outil Ant, mais fournit des moyens de configuration plus simples, eux aussi basés sur le format XML. Maven est géré par l'organisation Apache Software Foundation. Précédemment Maven était une branche de l'organisation Jakarta Project.

VI - Liens utiles

Introduction à ANT - partie 1
Introduction à ANT - partie 2
Développons en Java : Ant

VII - Téléchargement de sources

Télécharger

VIII - Conclusion

En les structurant dans un fichier XML, Ant offre une plus grande lisibilité des opérations qu'on peut exécuter sur un projet. L'intérêt principal est qu'on ne doit plus exécuter les tâches routinières (ennuyantes !!) de compilation, d'archivage et d'exécution à chaque fois qu'on modifie une ligne dans un fichier source du projet : Ant se chargera de faire tout cela pour nous.

IX - Remerciements

Un grand merci à _Mac_ pour sa relecture attentive. Je remercie aussi Ricky81 pour m'avoir guidé, et CheryBen pour ses commentaires et critiques très instructifs.