Exemples d'utilisation de ANT

De Wiki de Romain RUDIGER
Aller à : navigation, rechercher

Le fichier build.xml

Le fichier build.xml suivant représente l'exemple HelloWorld utiliser pour comprendre le fonctionnement d'ANT.

<project name="ANTTestProject" default="default" basedir=".">
	<property name="src" location="src"/>
	<property name="build" location="build"/>
	<taskdef resource="checkstyletask.properties"
	         classpath="/path/to/checkstyle-all-4.4.jar"/>
    <target name="clean">
        <delete dir="${build}"/>
    </target>
    <target name="compile">
        <mkdir dir="build/classes"/>
        <javac srcdir="src" destdir="build/classes"/>
    </target>
    <target name="jar" depends="compile">
        <mkdir dir="build/jar"/>
        <jar destfile="build/jar/HelloWorld.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="test.HelloWorld"/>
            </manifest>
        </jar>
    </target>
    <target name="run" depends="jar">
        <java jar="build/jar/HelloWorld.jar" fork="true"/>
    </target>
    <target name="default" depends="clean,run,jar,compile" >
    </target>
    <typedef name="slave" classname="${build}.classes.test.Slave">
	<classpath>
	    	<pathelement location="${build}/jar"/>
	</classpath>
    </typedef>
</project>

Pour détailler ce fichier, nous pouvons dire que la première balise définie le nom du projet: ANTTestProject ansi que la tâche à exectuer par défaut (default) si aucune option est définie au lancement de la compilation et la localisation du répertoire racine ("." signifie répertoire courant) où est situé ce fichier build.xml et le contenu du projet à compiler.


La balise 'property' définie des variables qui représente ici des chemins vers des dossiers.


La balise 'taskdef' permet de définir une tâche externe. Ici, c'est un fichier JAR.


La balise 'target' définie un ensemble de tâche à réaliser. Elle est constituée d'un 'name' qui permet de l'identifier et de l'appeler en tant qu'option de la ligne de commande utiliser pour le lancement de la compilation.


A l'intérieur du premier target, on distingue deux opérations reconnues par ANT: mkdir, qui va créer un répertoire et javac, qui va lancer la compilation de fichiers sources JAVA.


Une balise 'target' peut utiliser l'option 'depends' qui va contenir un ensemble de nom d'opérations à effectuer avant de réaliser l'execution des tâches contenues dans le target. L'execution des tâches prérequises se fait séquentiellement; dans l'ordre spécifié.


Utilisation de la commande ANT

Pour utiliser ce fichier build.xml et lancer la compilation du projet ou des opérations simples, il est possible UNIQUEMENT d'utiliser ses lignes de commandes dans un Terminal Windows pour cet exemple.

ant
ant default
ant clean
ant compile
ant jar
ant run

Ainsi les deux premières commandes lancerons la compilation du projet en utilisant la tâche 'default'. Cette tâche dépend d'autre tâches ainsi, ANT executera dans l'ordre: clean, run, jar, compile. Clean permet de détruire les fichiers non nécessaires (tâche réguliérement présente dans un build.xml). Run dépend de jar qui lui même dépend de compile. Ainsi le Build se fera en compilant dans un premier temps le projet, qui ensuite laissera place à la construction d'un fichier JAR. Ce fichier JAR sera executé par l'opération run.

ANT permet de faire toutes ses étapes en une ligne MS-Dos.

Les autres commandes n'executerons que leurs tâches et celles dont elles dépendent. Exemple: 'ant compile' ne fera que la compilation du projet.

Utilisation de l'API JAVA ANT

MyTask.java

Cette classe JAVA définie une Task personnel que l'on créé en héritant de la classe Task. Ici, la Task a pour fonction d'écrire le nom qu'elle porte sur la sortie standard: System.out.println("name:" + name);.

package tasks;

import org.apache.tools.ant.Task;
import org.apache.tools.ant.BuildException;

public class MyTask extends Task {
	
	// Attribute
	private String name;
	
	// Attribute Getter
	public String getName() {
		return name;
	}
	
	// Attribute Setter
	public void setName(String name) {
		this.name = name;
	}
	
	// Text nested between the start end end tags
	public void addText(String comment) {
		
	}
	
	public Object createName() {
		return null;
	}
	
	public void addName(Object o) {
		name = (String)o;
	}
	
	public void addConfiguredName(Object o) {
		name = (String)o;
	}
	
	// Iteration of the task
	public void execute() throws BuildException {
		this.setName("mytask");
		System.out.println("name:" + name);
	}

}

MyTarget.java

Ce Target définie un ensemble de classe et équivaut à la balise target que l'on peut voir dans le fichier build.xml précédant. Ce Target contient une Task "myTask". Lorsqu'il est appelé par ANT, ce Target execute l'ensemble des Tasks situées dans le tableau de Tasks.

package tasks;

import org.apache.tools.ant.Target;
import org.apache.tools.ant.BuildException;

public class MyTarget extends Target {

	public MyTarget() {
		this.setName("mytarget");
		// Adding a task in the Target
		MyTask mytask = new MyTask();
		this.addTask(mytask);
		
	}
	
	public void execute() throws BuildException {
		// Execute all Tasks
		for (int i = 0; i < getTasks().length; i++ ) {
			getTasks()[i].execute();
		}
	}
}

Launcher.java

Le Launcher permet de lancer l'application JAVA. Il contient la méthode main qui créé un MyProject et lance la compilation de MyProject comme si l'on exécuté dans un terminal 'ant' en étant situé dans le répertoire source du projet.

package projet;

import event.*;
import mypackage.*;
import tasks.*;
import projet.MyProject;

public class Launcher {

	public static void main(String args[]) {
		MyProject p = new MyProject();
		p.init();
	}
}

MyProject.java

MyProject est un Object JAVA décrivant la balise Project d'un build.xml. Au projet, nous devons renseigner le nom, le répertoire racine et le Target par défaut. Dans la méthode init(); il est spécifié les opérations qui seront effectué au lancement du programme. On peut remarquer qu'un MyListener a été ajouté. C'est un écouteur qui permet de visualiser l'avancement du build lors de l'execution. Ici, le projet lancera le Target myTarget qui lui même contient une MyTask et MyTask a pour but d'écrire son nom dans la console.

package projet;

import org.apache.tools.ant.Project;
import event.MyListener;
import tasks.MyTarget;
import org.apache.tools.ant.Target;

public class MyProject extends Project {
	
	public MyProject() {
		this.addBuildListener(new MyListener());
		// Needed
		this.setName("MyProject2");
		this.setBasedir(".");
		this.setDefault("dist");
		
		// Add Targets
		MyTarget mytarget = new MyTarget();
		this.addTarget(mytarget);
		
		Target dist = new Target();
		dist.setName("dist");
		dist.setDepends("compile");
		
		
	}
	
	public void init() {
		this.executeTarget("mytarget");
	}
}

MyListener.java

MyListener dérive de BuildListener et permet de définir les actions à effectuer lorsqu'un événement survient. Ici, on se contente d'écrire dans la console le nom de la méthode déclenchée et le message contenu dans le le BuildEvent.

package event;

import org.apache.tools.ant.BuildListener;
import org.apache.tools.ant.BuildEvent;

public class MyListener implements BuildListener {
 
	public void buildStarted(BuildEvent arg0) {
		System.out.println("buildStarted " + arg0.getMessage());
	}
  
	public void buildFinished(BuildEvent arg0) {
		System.out.println("buildFinished " + arg0.getMessage());
	}
  
	public void targetStarted(BuildEvent arg0) {
		System.out.println("targetStarted " + arg0.getMessage());
	}
  
	public void targetFinished(BuildEvent arg0) {
		System.out.println("targetFinished " + arg0.getMessage());
	}
  
	public void taskStarted(BuildEvent arg0) {
		System.out.println("taskStarted " + arg0.getMessage());
	}
  
	public void taskFinished(BuildEvent arg0) {
		System.out.println("taskFinished " + arg0.getMessage());
	}
  
	public void messageLogged(BuildEvent arg0) {
		System.out.println("messageLogged " + arg0.getMessage());
	}
}

Voici donc un bon exemple permettant de reprendre l'API d'ANT.