Tutoriel Apache ANT

⚡ Résumé intelligent

Apache Ant est un logiciel libre, JavaOutil de construction basé sur `build.xml` qui automatise la compilation, les tests, l'empaquetage et le déploiement via un seul fichier `build.xml`. Intégré avec Selenium et TestNG, il rend l'exécution des tests reproductible, organisée et facile à exécuter n'importe où.

  • 🐜 Rôle principal : Ant stocke et exécute les étapes de construction séquentiellement à partir d'un fichier de configuration XML.
  • ⚙️ Cycle de vie du bâtiment : Un seul fichier gère le nettoyage, la compilation, la définition du classpath, l'exécution et la génération de rapports.
  • 📦 Structure du fichier build.xml : Les balises de projet, de cible, de tâche et de propriété définissent chaque étape de la construction.
  • 🔧 Installation: Définissez la variable ANT_HOME et ajoutez %ANT_HOME%\bin au chemin système.
  • 🧪 Selenium et TestNG: Ant invoque testng.xml afin que les suites de tests s'exécutent pendant la compilation.
  • 🚀 Contrôle des dépendances : Les chemins d'accès aux fichiers JAR tiers sont centralisés, ce qui améliore la fiabilité et le déploiement.

Apache Ant avec Selenium

Qu’est-ce qu’Apache Ant ?

Lors de la création d'un produit logiciel complet, il faut s'occuper des différentes API tierces, de leur chemin de classe, du nettoyage des fichiers binaires exécutables précédents, de la compilation de notre code source, de l'exécution du code source, de la création de rapports et de la base de code de déploiement, etc. Si ces tâches sont effectué un par un manuellement, cela prendra énormément de temps et le processus sera sujet à des erreurs.

Voici l'importance d'un outil de construction comme Ant. Il stocke, exécute et automatise tous les processus dans un ordre séquentiel mentionné dans le fichier de configuration d'Ant (généralement build.xml).

Fourmi Apache

Avantage de la construction Ant

  1. Ant crée le cycle de vie de l'application, c'est-à-dire nettoyer, compiler, définir les dépendances, exécuter, créer un rapport, etc.
  2. La dépendance à l'API tierce peut être définie par Ant, c'est-à-dire que le chemin de classe d'un autre fichier Jar est défini par le fichier de construction Ant.
  3. Une application complète est créée pour la livraison et le déploiement de bout en bout.
  4. Il s'agit d'un outil de construction simple où toutes les configurations peuvent être effectuées à l'aide d'un fichier XML et qui peut être exécuté à partir de la ligne de commande.
  5. Cela rend votre code propre car la configuration est distincte de la logique réelle de l'application.

Comment installer Ant

Étapes pour installer Ant dans Windows est comme suit

Étape 1) Allez dans https://ant.apache.org/bindownload.cgi Ou téléchargez le fichier .zip depuis apache-ant-1.9.4-bin.zip

Installer Ant

Étape 2) Décompressez le dossier, accédez à et copiez le chemin vers la racine du dossier décompressé.

Installer Ant

Étape 3) Allez dans Démarrer -> Ordinateur -> faites un clic droit ici et sélectionnez « Propriétés », puis cliquez sur Paramètres système avancés.

Installer Ant

Étape 4) Une nouvelle fenêtre s'ouvre. Cliquez sur le bouton « Variable d'environnement… ».

Installer Ant

Étape 5) Cliquez sur le bouton « Nouveau… » et définissez le nom de la variable sur « ANT_HOME » et la valeur de la variable comme chemin racine du dossier décompressé, puis cliquez sur OK.

Installer Ant

Étape 6) sélectionnez maintenant la variable « Chemin » dans la liste, cliquez sur « Modifier » et ajoutez ; %ANT_HOME%\bin.

Installer Ant

Redémarrez le système une fois et vous êtes maintenant prêt à utiliser l'outil de construction Ant.

Étape 7) Pour vérifier la version de votre Ant en utilisant la ligne de commande :

Version fourmi

Installer Ant

Comprendre Build.xml

Build.xml est le composant le plus important de l'outil de construction Ant. Pour un Java projet, toutes les tâches liées au nettoyage, à l'installation, à la compilation et au déploiement sont mentionnées dans ce fichier au format XML. Lorsque nous exécutons ce fichier XML à l'aide de la ligne de commande ou de n'importe quel plugin IDE, toutes les instructions écrites dans ce fichier seront exécutées de manière séquentielle.

Comprenons le code dans un exemple de build.XML

  • La balise Project est utilisée pour mentionner un nom de projet et un attribut basedir. Le basedir est le répertoire racine d'une application
    <project name="YTMonetize" basedir=".">
  • Les balises de propriété sont utilisées comme variables dans le fichier build.XML à utiliser dans les étapes suivantes
<property name="build.dir" value="${basedir}/build"/>
		<property name="external.jars" value=".\resources"/>
	<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
  • Target balises utilisées comme étapes qui s'exécuteront dans un ordre séquentiel. L'attribut Name est le nom de la cible. Vous pouvez avoir plusieurs cibles dans un seul build.xml
    <target name="setClassPath">
  • La balise de chemin est utilisée pour regrouper logiquement tous les fichiers qui se trouvent à l'emplacement commun
    <path id="classpath_jars">
  • La balise pathelement définira le chemin d'accès à la racine de l'emplacement commun où tous les fichiers sont stockés
    <pathelement path="${basedir}/"/>
  • balise pathconvert utilisée pour convertir les chemins de tous les fichiers courants à l'intérieur de la balise de chemin au format de chemin de classe du système
    <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
  • balise fileset utilisée pour définir le chemin de classe pour différents fichiers jar tiers dans notre projet
    <fileset dir="${ytoperation.dir}" includes="*.jar"/>
  • La balise Echo est utilisée pour imprimer du texte sur la console
<echo message="deleting existing build directory"/>
  • La balise Supprimer nettoiera les données du dossier donné
<delete dir="${build.dir}"/>
  • La balise mkdir créera un nouveau répertoire
	<mkdir dir="${build.dir}"/>
  • balise javac utilisée pour compiler le code source Java et déplacer les fichiers .class vers un nouveau dossier
        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>
  • La balise jar créera un fichier jar à partir de fichiers .class
	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
  • La balise manifest définira votre classe principale pour l'exécution
<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>
  • attribut 'depends' utilisé pour faire dépendre une cible d'une autre cible
<target name="run" depends="compile">
  • La balise java exécutera la fonction principale à partir du pot créé dans la section cible de compilation
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Exécutez Ant en utilisant Eclipse plug-in

Pour exécuter Ant depuis Eclipse, accédez au fichier build.xml -> cliquez avec le bouton droit sur le fichier -> Exécuter en tant que… -> cliquez sur Créer le fichier

Exécutez Ant en utilisant Eclipse Brancher

Exemple

Nous prendrons un petit exemple de programme qui expliquera très clairement la fonctionnalité Ant. La structure de notre projet ressemblera à –

Exécutez Ant en utilisant Eclipse Brancher

Ici, dans cet exemple, nous avons 4 cibles

  1. Définir le chemin de classe pour les fichiers jar externes,
  2. Nettoyer le code précédemment respecté
  3. Compiler le code Java existant
  4. Exécutez le code

Guru99AntClass.class

package testAnt;		
import java.util.Date;		

public class Guru99AntClass {				
   public static void main(String...s){									       
		System.out.println("HELLO GURU99 ANT PROGRAM");					        
		System.out.println("TODAY's DATE IS->"+ currentDate() );					  
}		    		   
public static String currentDate(){					        
	return new Date().toString();					  
	}		
}

Construire.xml

 
<?xml version="1.0" encoding="UTF-8"	standalone="no"?>									
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->	

<project name="YTMonetize" basedir=".">								
     <!--Property tags will be used as variables in build.xml file to use in further steps-->		

	<property name="build.dir" value="${basedir}/build"/>								
    <property name="external.jars" value=".\resources"/>								
		<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
<!--Target tags used as steps that will execute in sequential order. name attribute will be the name  of the target and < a name=OLE_LINK1 >'depends' attribute used to make one target to depend on another target -->		
	       <target name="setClassPath">					
			<path id="classpath_jars">						
				<pathelement	path="${basedir}/"/>					
			</path>				         
<pathconvert	pathsep=";"property="test.classpath" refid="classpath_jars"/>	
</target>				
	<target name="clean">						
		<!--echo tag will use to print text on console-->		
		<echo message="deleting existing build directory"/>						
		<!--delete tag will clean data from given folder-->		
		<delete dir="${build.dir}"/>						
	</target>				
<target name="compile" depends="clean,setClassPath">								
	<echo message="classpath:${test.classpath}"/>					
			<echo message="compiling.........."/>						
	<!--mkdir tag will create new director-->							
	<mkdir dir="${build.dir}"/>						
		<echo message="classpath:${test.classpath}"/>						
		<echo message="compiling.........."/>						
	<!--javac tag used to compile java source code and move .class files to a new folder-->		
	<javac destdir="${build.dir}" srcdir="${src.dir}">								
			<classpath refid="classpath_jars"/>						
	</javac>				
	<!--jar tag will create jar file from .class files-->		
	<jar	destfile="${ytoperation.dir}/YTOperation.jar"basedir="${build.dir}">								
	            <!--manifest tag will set your main class for execution-->		
						<manifest>				
							<attribute name="Main-Class" value="testAnt.Guru99AntClass"/>  
</manifest>		
</jar>				
    </target>				
	<target name="run" depends="compile">								
		<!--java tag will execute main function from the jar created in compile target section-->	
<java jar="${ytoperation.dir}/YTOperation.jar"fork="true"/>			
</target>				
	</project>				

Exécutez Ant en utilisant Eclipse plug-in

Comment exécuter TestNG code utilisant Ant

Exécution TestNG code utilisant Ant

Ici, nous allons créer une classe avec Tester méthodes et définir le chemin de classe pour Tests dans build.xml.

Maintenant, pour exécuter la méthode testng, nous allons créer un autre fichier testng.xml et appeler ce fichier à partir du fichier build.xml.

Étape 1) Nous créons un "Guru99AntClass.class” en paquet testAnt

Guru99AntClass.class

package testAnt;
import java.util.Date;
import org.testng.annotations.Test;		
public class Guru99AntClass {				
    @Test		  
	public void Guru99AntTestNGMethod(){					     
		System.out.println("HELLO GURU99 ANT PROGRAM");					
		System.out.println("TODAY's DATE IS->"+ currentDate() );					
	}		
	public static String currentDate(){					
		return new Date().toString();					
	}		
}		

Étape 2) Créez une cible pour charger cette classe dans Build.xml

<!-- Load testNG and add to the class path of application -->
	<target name="loadTestNG" depends="setClassPath">
<!—using taskdef  tag we can add a task to run on the current project. In below line, we are adding testing task in this project. Using testing task here now we can run testing code using the ant script -->
		<taskdef resource="testngtasks" classpath="${test.classpath}"/>
</target>

Étape 3) Créer testng.xml

testng.xml

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="YT"thread-count="1">
			<test name="GURU99TestNGAnt">
			<classes>
			   <class name="testAnt.Guru99AntClass">
	</class>
</classes>
</test>
</suite>

Étape 4) Créer Target dans Build.xml pour exécuter ceci TestNG code

<target name="runGuru99TestNGAnt" depends="compile">
<!-- testng tag will be used to execute testng code using corresponding testng.xml file. Here classpath attribute is setting classpath for testng's jar to the project-->
	<testng classpath="${test.classpath};${build.dir}">
<!—xmlfileset tag is used here to run testng's code using testing.xml file. Using includes tag we are mentioning path to testing.xml file-->
	 <xmlfileset dir="${basedir}" includes="testng.xml"/>
</testng>				

Étape 5) Le Build.xml complet

<?xml version="1.0"encoding="UTF-8"standalone="no"?>
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
			<project name="YTMonetize" basedir=".">
		       <!--Property tags will be used as variables in build.xml file to use in further steps-->
			<property name="build.dir"value="${basedir}/build"/>
<!-- put  testng related jar in the resource  folder -->
	      <property name="external.jars" value=".\resource"/>
				<property name="src.dir" value="${basedir}/src"/>
<!--Target tags used as steps that will execute in  sequential order. name attribute will be the name
    of the target and 'depends' attribute used to make one target to depend on another target-->
<!-- Load testNG and add to the class path of application -->
         <target name="loadTestNG"depends="setClassPath">
				<taskdef resource="testngtasks"classpath="${test.classpath}"/>
		</target>
		<target name="setClassPath">
		       <path id="classpath_jars">
					<pathelement path="${basedir}/"/>
					<fileset dir="${external.jars}" includes="*.jar"/>
         </path>
        <pathconvert pathsep=";"property="test.classpath"refid="classpath_jars"/>
	</target>
	<target name="clean">
              <!--echo tag will use to print text on console-->
	               <echo message="deleting existing build directory"/>
               <!--delete tag will clean data from given folder-->
	               <delete				dir="${build.dir}"/>
			</target>
<target name="compile"depends="clean,setClassPath,loadTestNG">
	         <echo message="classpath:${test.classpath}"/>
	               <echo	message="compiling.........."/>
		       <!--mkdir tag will create new director-->
		        <mkdir dir="${build.dir}"/>
					<echo message="classpath:${test.classpath}"/>
			<echo message="compiling.........."/>
	<!--javac tag used to compile java source code and move .class files to a new folder-->
	        <javac destdir="${build.dir}"srcdir="${src.dir}">
	             <classpath refid="classpath_jars"/>
		</javac>
  </target>
<target name="runGuru99TestNGAnt"depends="compile">
		<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
			<testng classpath="${test.classpath};${build.dir}">
               <xmlfileset dir="${basedir}"includes="testng.xml"/>
	</testng>
</target>
</project>

Étape 6) Sortie

Exécution TestNG code utilisant Ant

Téléchargez le fichier ci-dessus

Avec Ant gérant la construction et TestNG Une fois le câblage effectué, l'étape suivante connecte Ant directement à Selenium Pilote Web.

Fourmi avec Selenium Pilote Web

Jusqu'à présent, nous avons appris qu'avec Ant, nous pouvons placer tous les fichiers JAR tiers dans un emplacement précis du système et définir leur chemin d'accès pour notre projet. Cette méthode permet de centraliser toutes les dépendances de notre projet et d'améliorer sa fiabilité lors de la compilation, de l'exécution et du déploiement.

De même, pour nos projets de test utilisant le sélénium, nous pouvons facilement mentionner la dépendance au sélénium dans build.xml et nous n'avons pas besoin d'en ajouter manuellement un chemin de classe dans notre application.

Alors maintenant, vous pouvez ignorer la méthode traditionnelle mentionnée ci-dessous pour définir les chemins de classe pour le projet.

Fourmi avec Selenium Pilote Web

Exemple :

Nous allons modifier l'exemple précédent

Étape 1) Définissez la propriété selenium.jars sur le pot lié au sélénium dans le dossier de ressources

		<property name="selenium.jars" value=".\selenium"/>

Étape 2) Dans le setClassPath cible, ajoutez les fichiers Selenium

<target name="setClassPath">
	        <path id="classpath_jars">
				<pathelement path="${basedir}/"/>	
				<fileset dir="${external.jars}" includes="*.jar"/>
	            <!-- selenium jar added here -->
  		            <fileset dir="${selenium.jars}" includes="*.jar"/>
         </path>		

Étape 3) Complétez le fichier Build.xml :

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
			<project name="YTMonetize" basedir=".">
                  <!--Property tags will be used as variables in build.xml file to use in further steps-->
				<property name="build.dir" value="${basedir}/build"/>
      <!-- put  testng related jar in the resource  folder -->
	       <property name="external.jars" value=".\resource"/>
<!-- put  selenium related jar in resource  folder -->
     <property name="selenium.jars" value=".\selenium"/>
			<property name="src.dir" value="${basedir}/src"/>
				<!--Target tags used as steps that will execute in  sequential order. name attribute will be the name 
of the target and 'depends' attribute used to make one target to depend on another target-->
      <!-- Load testNG and add to the class path of application -->
       <target name="loadTestNG" depends="setClassPath">
				<taskdef resource="testngtasks" classpath="${test.classpath}"/>
		</target>
<target name="setClassPath">
	        <path id="classpath_jars">
				<pathelement path="${basedir}/"/>
					<fileset dir="${external.jars}" includes="*.jar"/>
			<!-- selenium jar added here -->
	            <fileset dir="${selenium.jars}"includes="*.jar"/>
        </path>
   <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
</target>
<target name="clean">
<!--echo tag will use to print text on console-->
               <echo message="deleting existing build directory"/>
	                <!--delete tag will clean data from given folder-->
		               <delete dir="${build.dir}"/>
				</target>
<target name="compile" depends="clean,setClassPath,loadTestNG">
         <echo message="classpath:${test.classpath}"/>
                <echo message="compiling.........."/>
        <!--mkdir tag will create new director-->
	        <mkdir dir="${build.dir}"/>
          			<echo message="classpath:${test.classpath}"/>
			<echo message="compiling.........."/>
	<!--javac tag used to compile java source code and move .class files to new folder-->
     <javac destdir="${build.dir}"srcdir="${src.dir}">
             <classpath refid="classpath_jars"/>
	</javac>
</target>
<target name="runGuru99TestNGAnt" depends="compile">
		<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
			<testng classpath="${test.classpath};${build.dir}">
               <xmlfileset dir="${basedir}" includes="testng.xml"/>
		</testng>
	</target>
</project>

Étape 4) Modifiez maintenant la classe précédemment créée. Guru99AntClass.java avec un nouveau code.

Ici, dans cet exemple, nos étapes utilisant Selenium sont:

  1. Allez dans https://demo.guru99.com/test/guru99home/
  2. Lire tous les liens des cours un par un
  3. Imprimez le lien hypertexte de tous les cours sur la console.

Guru99AntClass.java :

package testAnt;		
import java.util.List;		
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;	
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.Test;

public class Guru99AntClass {

	@Test		
		public void Guru99AntTestNGMethod(){
	      WebDriver driver = new FirefoxDriver();	
		  driver.get("https://demo.guru99.com/test/guru99home/");
		  List<WebElement> listAllCourseLinks = driver.findElements(By.xpath("//div[@class='canvas-middle']//a"));							        
          for(WebElement webElement : listAllCourseLinks) {
			System.out.println(webElement.getAttribute("href"));
      	  }
		}
}		

Étape 5) Après une exécution réussie, le résultat ressemblera à :

Fourmi avec Selenium Pilote Web

Téléchargez le fichier d'exemple ci-dessus

FAQ

Ant est un outil de construction procédurale où chaque étape est scriptée manuellement, tandis que Maven est déclaratif et gère automatiquement les dépendances via un dépôt central. Ant offre plus de contrôle ; Maven privilégie les conventions.

Oui. Beaucoup d'héritages Java et Selenium Les projets s'appuient encore sur Ant pour les compilations et l'intégration continue. Les projets plus récents optent souvent pour Maven ou Gradlemais Ant reste utile pour un contrôle précis de la compilation.

Apache Ant 1.10.x est la série activement maintenue et nécessite Java 8 ou version ultérieure. La version 1.9.x plus ancienne prend en charge les fonctionnalités héritées. JavaTéléchargez toujours les fichiers binaires depuis le site officiel ant.apache.org.

Oui. Les assistants IA tels que ChatGPT ou Copilot génèrent les cibles build.xml, suggèrent des définitions de tâches et expliquent les erreurs. RevExaminez attentivement le fichier XML généré, car les chemins d'accès et les versions des dépendances doivent encore être vérifiés.

Les outils basés sur l'IA génèrent TestNG Ces suites de tests optimisent l'ordre des tests et signalent les tests instables déclenchés par les cibles Ant. Elles réduisent la maintenance en suggérant des corrections de localisation et en analysant automatiquement les rapports de compilation.

Non. Ant peut compiler et exécuter du texte brut. Java or JUnit des tests aussi. TestNG ajoute simplement une configuration de suite flexible via testng.xml, qu'Ant invoque à l'aide de la tâche testng lors de la compilation.

La variable d'environnement ANT_HOME indique au système d'exploitation où Ant est installé, ce qui permet d'exécuter la commande ant depuis n'importe quel répertoire. Vous ajoutez %ANT_HOME%\bin au chemin système lors de l'installation. Windows.

Gradle Pour les nouveaux projets, Ant est généralement privilégié car il combine la flexibilité d'Ant avec la gestion des dépendances de Maven et des compilations incrémentales plus rapides. On choisit Ant principalement pour la maintenance des scripts de compilation existants.

Résumez cet article avec :