Apache ANT-Tutorial

โšก Intelligente Zusammenfassung

Apache Ant ist Open Source, Java-basiertes Build-Tool, das Kompilieren, Testen, Verpacken und Bereitstellen รผber eine einzige build.xml-Datei automatisiert. Integriert mit Selenium und TestNGDadurch wird die Testausfรผhrung wiederholbar, organisiert und kann problemlos รผberall durchgefรผhrt werden.

  • ???? Kernaufgabe: Ant speichert und fรผhrt die Build-Schritte sequenziell aus einer XML-Konfigurationsdatei aus.
  • โš™๏ธ Build-Lebenszyklus: Eine einzige Datei รผbernimmt das Bereinigen, Kompilieren, Festlegen des Klassenpfads, Ausfรผhren und Berichten.
  • ๐Ÿ“ฆ Struktur der build.xml-Datei: Projekt-, Ziel-, Aufgaben- und Eigenschafts-Tags definieren jeden Build-Schritt.
  • ๐Ÿ”ง Installation: Setzen Sie die ANT_HOME-Variable und fรผgen Sie %ANT_HOME%\bin zum Systempfad hinzu.
  • ๐Ÿงช Selenium und TestNG: Ant ruft testng.xml auf, damit die Testsuiten wรคhrend des Build-Prozesses ausgefรผhrt werden.
  • ๐Ÿš€ Abhรคngigkeitskontrolle: Die Pfade fรผr JAR-Dateien von Drittanbietern werden zentralisiert, was die Zuverlรคssigkeit und Bereitstellung verbessert.

Apache Ant mit Selenium

Was ist Apache Ant?

Beim Erstellen eines vollstรคndigen Softwareprodukts muss man sich um verschiedene APIs von Drittanbietern, deren Klassenpfade, das Bereinigen frรผherer ausfรผhrbarer Binรคrdateien, das Kompilieren unseres Quellcodes, die Ausfรผhrung des Quellcodes, die Erstellung von Berichten und die Bereitstellungscodebasis usw. kรผmmern Wenn Sie die Schritte einzeln manuell durchfรผhren, wird dies enorm viel Zeit in Anspruch nehmen und der Prozess ist fehleranfรคllig.

Hier zeigt sich die Bedeutung eines Build-Tools wie Ant. Es speichert, fรผhrt und automatisiert alle Prozesse in einer sequenziellen Reihenfolge, die in der Konfigurationsdatei von Ant (normalerweise build.xml) angegeben ist.

Apache-Ameise

Vorteil des Ant-Builds

  1. Ant erstellt den Anwendungslebenszyklus, d. h. Bereinigen, Kompilieren, Festlegen von Abhรคngigkeiten, Ausfรผhren, Berichten usw.
  2. Die API-Abhรคngigkeit von Drittanbietern kann von Ant festgelegt werden, d. h. der Klassenpfad anderer Jar-Dateien wird von der Ant-Build-Datei festgelegt.
  3. Es wird eine vollstรคndige Anwendung fรผr die End-to-End-Bereitstellung und -Bereitstellung erstellt.
  4. Es handelt sich um ein einfaches Build-Tool, bei dem alle Konfigurationen mithilfe einer XML-Datei vorgenommen und รผber die Befehlszeile ausgefรผhrt werden kรถnnen.
  5. Dadurch bleibt Ihr Code sauber, da die Konfiguration von der eigentlichen Anwendungslogik getrennt ist.

So installieren Sie Ant

Schritte zur Installation von Ant Windows ist wie folgt

Schritt 1) Zurรผck Nach https://ant.apache.org/bindownload.cgi Oder laden Sie die ZIP-Datei herunter von apache-ant-1.9.4-bin.zip

Installieren Sie Ant

Schritt 2) Entpacken Sie den Ordner und kopieren Sie den Pfad zum Stammverzeichnis des entpackten Ordners

Installieren Sie Ant

Schritt 3) Gehen Sie zu Start -> Computer -> klicken Sie mit der rechten Maustaste hier, wรคhlen Sie โ€žEigenschaftenโ€œ und klicken Sie dann auf โ€žErweiterte Systemeinstellungenโ€œ.

Installieren Sie Ant

Schritt 4) Es รถffnet sich ein neues Fenster. Klicken Sie auf die Schaltflรคche โ€žUmgebungsvariableโ€ฆโ€œ.

Installieren Sie Ant

Schritt 5) Klicken Sie auf die Schaltflรคche โ€žNeuโ€ฆโ€œ, legen Sie den Variablennamen auf โ€žANT_HOMEโ€œ und den Variablenwert als Stammpfad zum entpackten Ordner fest und klicken Sie auf โ€žOKโ€œ.

Installieren Sie Ant

Schritt 6) Wรคhlen Sie nun die Variable โ€žPfadโ€œ aus der Liste aus und klicken Sie auf โ€žBearbeitenโ€œ und anhรคngen; %ANT_HOME%\bin.

Installieren Sie Ant

Starten Sie das System einmal neu und Sie kรถnnen das Ant-Build-Tool jetzt verwenden.

Schritt 7) So รผberprรผfen Sie die Version Ihres Ant รผber die Befehlszeile:

Ant-Version

Installieren Sie Ant

Build.xml verstehen

Build.xml ist die wichtigste Komponente des Ant-Build-Tools. Fรผr ein Java Im Projekt werden alle Reinigungs-, Einrichtungs-, Kompilierungs- und Bereitstellungsaufgaben in dieser Datei im XML-Format aufgefรผhrt. Wenn wir diese XML-Datei รผber die Befehlszeile oder ein beliebiges IDE-Plugin ausfรผhren, werden alle in diese Datei geschriebenen Anweisungen nacheinander ausgefรผhrt.

Lassen Sie uns den Code in einem build.XML-Beispiel verstehen

  • Das Projekt-Tag wird verwendet, um einen Projektnamen und ein basedir-Attribut zu erwรคhnen. Das basedir ist das Stammverzeichnis einer Anwendung
    <project name="YTMonetize" basedir=".">
  • Eigenschafts-Tags werden als Variablen in der Datei build.XML verwendet, um in weiteren Schritten verwendet zu werden
<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, die als Schritte verwendet werden, die in sequenzieller Reihenfolge ausgefรผhrt werden. Das Attribut โ€žNameโ€œ ist der Name des Ziels. Sie kรถnnen mehrere Ziele in einer einzigen build.xml haben.
    <target name="setClassPath">
  • Das Pfad-Tag wird verwendet, um alle Dateien, die sich am gemeinsamen Speicherort befinden, logisch zu bรผndeln
    <path id="classpath_jars">
  • Das Pathelement-Tag legt den Pfad zum Stammverzeichnis des gemeinsamen Speicherorts fest, an dem alle Dateien gespeichert sind
    <pathelement path="${basedir}/"/>
  • pathconvert-Tag, das zum Konvertieren der Pfade aller gรคngigen Dateien innerhalb des Path-Tags in das Klassenpfadformat des Systems verwendet wird
    <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
  • Dateisatz-Tag, das zum Festlegen des Klassenpfads fรผr verschiedene JAR-Dateien von Drittanbietern in unserem Projekt verwendet wird
    <fileset dir="${ytoperation.dir}" includes="*.jar"/>
  • Das Echo-Tag wird zum Drucken von Text auf der Konsole verwendet
<echo message="deleting existing build directory"/>
  • Tag lรถschen lรถscht Daten aus dem angegebenen Ordner
<delete dir="${build.dir}"/>
  • Mit dem mkdir-Tag wird ein neues Verzeichnis erstellt
	<mkdir dir="${build.dir}"/>
  • javac-Tag, das zum Kompilieren von Java-Quellcode und zum Verschieben von .class-Dateien in einen neuen Ordner verwendet wird
        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>
  • Das Jar-Tag erstellt eine JAR-Datei aus .class-Dateien
	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
  • Das Manifest-Tag legt Ihre Hauptklasse fรผr die Ausfรผhrung fest
<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>
  • Das Attribut โ€žabhรคngigโ€œ wird verwendet, um ein Ziel von einem anderen Ziel abhรคngig zu machen
<target name="run" depends="compile">
  • Das Java-Tag fรผhrt die Hauptfunktion aus dem im Kompilierungszielabschnitt erstellten JAR aus
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Fรผhren Sie Ant mit aus Eclipse Plugin

Um Ant von Eclipse aus auszufรผhren, gehen Sie zur Datei build.xml -> Rechtsklick auf die Datei -> Ausfรผhren alsโ€ฆ -> klicken Sie auf Datei erstellen

Fรผhren Sie Ant mit aus Eclipse Plugin

Beispiel

Wir nehmen ein kleines Beispielprogramm, das die Ant-Funktionalitรคt sehr anschaulich erklรคrt. Unsere Projektstruktur wird wie folgt aussehen:

Fรผhren Sie Ant mit aus Eclipse Plugin

Hier in diesem Beispiel haben wir 4 Ziele

  1. Klassenpfad fรผr externe Glรคser festlegen,
  2. Bereinigen Sie zuvor kompilierten Code
  3. Kompilieren Sie vorhandenen Java-Code
  4. Fรผhren Sie den Code aus

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();					  
	}		
}

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"/>								
    <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>				

Fรผhren Sie Ant mit aus Eclipse Plugin

Wie man ausfรผhrt TestNG Code mit Ant

Ausfรผhren TestNG Code mit Ant

Hier erstellen wir eine Klasse mit Testng Methoden und legen Sie den Klassenpfad fest Tests in build.xml.

Um nun die Testng-Methode auszufรผhren, erstellen wir eine weitere testng.xml-Datei und rufen diese Datei aus der Datei build.xml auf.

Schritt 1) Wir schaffen eine "Guru99AntClass.classโ€ im Paket 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();					
	}		
}		

Schritt 2) Erstellen Sie ein Ziel, um diese Klasse in Build.xml zu laden

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

Schritt 3) Erstellen Sie 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>

Schritt 4) Erschaffung Target in Build.xml, um dies auszufรผhren 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>				

Schritt 5) Die vollstรคndige 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"/>
				<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>

Schritt 6) Ausgang

Ausfรผhren TestNG Code mit Ant

Laden Sie die obige Datei herunter

Ant verwaltet den Build und TestNG Nachdem die Verkabelung hergestellt ist, wird im nรคchsten Schritt Ant direkt mit Selenium WebDriver.

Ameise mit Selenium Webtreiber

Bisher haben wir gelernt, dass wir mit Ant alle Drittanbieter-JAR-Dateien an einem bestimmten Ort im System ablegen und deren Pfad fรผr unser Projekt festlegen kรถnnen. Dadurch werden alle Abhรคngigkeiten unseres Projekts zentralisiert, was die Zuverlรคssigkeit bei Kompilierung, Ausfรผhrung und Bereitstellung erhรถht.

Ebenso kรถnnen wir fรผr unsere Testprojekte mit Selenium die Selenium-Abhรคngigkeit problemlos in build.xml erwรคhnen und mรผssen unserer Anwendung keinen Klassenpfad manuell hinzufรผgen.

Jetzt kรถnnen Sie die unten erwรคhnte herkรถmmliche Methode zum Festlegen von Klassenpfaden fรผr Projekte ignorieren.

Ameise mit Selenium Webtreiber

Ejemplo:

Wir werden das vorherige Beispiel modifizieren

Schritt 1) Setzen Sie die Eigenschaft selenium.jars auf Selenium-bezogenes Jar im Ressourcenordner

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

Schritt 2) Fรผgen Sie im Ziel setClassPath die Selenium-Dateien hinzu

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

Schritt 3) Komplette 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>

Schritt 4) ร„ndern Sie nun die zuvor erstellte Klasse. Guru99AntClass.java mit neuem Code.

Hier in diesem Beispiel unsere Schritte mit Selenium sind:

  1. Zurรผck Nach https://demo.guru99.com/test/guru99home/
  2. Lesen Sie alle Kurslinks einzeln durch
  3. Drucken Sie den Hyperlink โ€žAlle Kurseโ€œ auf der Konsole aus.

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"));
      	  }
		}
}		

Schritt 5) Nach erfolgreicher Ausfรผhrung sieht die Ausgabe so aus:

Ameise mit Selenium Webtreiber

Laden Sie die obige Beispieldatei herunter

Hรคufig gestellte Fragen

Ant ist ein prozedurales Build-Tool, bei dem jeder Schritt manuell per Skript festgelegt wird, wรคhrend Maven deklarativ ist und Abhรคngigkeiten automatisch รผber ein zentrales Repository verwaltet. Ant bietet mehr Kontrolle, Maven hingegen Konventionen.

Ja. Viele Altlasten Java und Selenium Projekte setzen weiterhin auf Ant fรผr Builds und Continuous Integration. Neuere Projekte wรคhlen hรคufig Maven oder GradleAnt bleibt jedoch fรผr die detaillierte Steuerung des Build-Prozesses nรผtzlich.

Apache Ant 1.10.x ist die aktiv gepflegte Version und erfordert Java 8 oder hรถher. Die รคltere 1.9.x-Reihe unterstรผtzt Legacy-Versionen. JavaLaden Sie Binรคrdateien immer von der offiziellen Website ant.apache.org herunter.

Ja. KI-Assistenten wie ChatGPT oder Copilot erstellen build.xml-Ziele, schlagen Aufgabendefinitionen vor und erklรคren Fehler. RevPrรผfen Sie das generierte XML sorgfรคltig, da Pfade und Abhรคngigkeitsversionen noch รผberprรผft werden mรผssen.

KI-gestรผtzte Werkzeuge generieren TestNG Sie optimieren die Testreihenfolge und kennzeichnen fehlerhafte Tests, die รผber Ant-Targets ausgelรถst werden. Durch automatische Vorschlรคge zur Fehlerbehebung und die Analyse von Build-Berichten reduzieren sie den Wartungsaufwand.

Nein. Ant kann einfache Programme kompilieren und ausfรผhren. Java or JUnit Tests auch. TestNG Es fรผgt lediglich eine flexible Suite-Konfiguration รผber testng.xml hinzu, die Ant wรคhrend des Build-Prozesses mithilfe der testng-Aufgabe aufruft.

ANT_HOME teilt dem Betriebssystem mit, wo Ant installiert ist, sodass der Befehl โ€žantโ€œ von jedem beliebigen Verzeichnis aus ausgefรผhrt werden kann. Sie hรคngen %ANT_HOME%\bin wรคhrend der Installation an den Systempfad an. Windows.

Gradle Ant wird รผblicherweise fรผr neue Projekte bevorzugt, da es die Flexibilitรคt von Ant mit der Abhรคngigkeitsverwaltung von Maven und schnelleren inkrementellen Builds kombiniert. Ant eignet sich vor allem zur Pflege bestehender Build-Skripte.

Fassen Sie diesen Beitrag mit folgenden Worten zusammen: