Prise en main d'Ant

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 :

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 :

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 :

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

java -jar exe\HelloWorld.jar

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.

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.

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.

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.

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.

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 :

<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

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.

<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.

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.