Tutorial de Apache ANT

⚡ Resumen inteligente

Apache Ant es un software de código abierto, JavaHerramienta de compilación basada en que automatiza la compilación, las pruebas, el empaquetado y la implementación a través de un único archivo build.xml. Integrado con Selenium y TestNGEsto hace que la ejecución de las pruebas sea repetible, organizada y fácil de realizar en cualquier lugar.

  • ???? Función principal: Ant almacena y ejecuta los pasos de compilación de forma secuencial a partir de un archivo de configuración XML.
  • ⚙️ Ciclo de vida de la compilación: Un único archivo se encarga de limpiar, compilar, configurar la ruta de clases, ejecutar y generar informes.
  • 📦 Estructura de build.xml: Las etiquetas de proyecto, objetivo, tarea y propiedad definen cada paso de la compilación.
  • 🔧 Instalación: Establezca la variable ANT_HOME y agregue %ANT_HOME%\bin a la ruta del sistema.
  • 🧪 Selenium y TestNG: Ant invoca testng.xml para que las suites se ejecuten durante la compilación.
  • 🚀 Control de dependencia: Las rutas de los archivos JAR de terceros están centralizadas, lo que mejora la fiabilidad y la implementación.

Hormiga Apache con Selenium

¿Qué es la hormiga apache?

Al crear un producto de software completo, es necesario ocuparse de las diferentes API de terceros, su classpath, limpiar los archivos binarios ejecutables anteriores, compilar nuestro código fuente, ejecutar el código fuente, crear informes y la base del código de implementación, etc. Si se hace uno por uno manualmente, llevará mucho tiempo y el proceso será propenso a errores.

Aquí viene la importancia de una herramienta de construcción como Ant. Almacena, ejecuta y automatiza todos los procesos en un orden secuencial mencionado en el archivo de configuración de Ant (normalmente build.xml).

Hormiga Apache

Beneficio de Ant build

  1. Ant crea el ciclo de vida de la aplicación, es decir, limpia, compila, establece dependencias, ejecuta, informa, etc.
  2. Ant puede establecer la dependencia de la API de terceros, es decir, la ruta de clase de otro archivo Jar la establece el archivo de compilación Ant.
  3. Se crea una aplicación completa para la entrega e implementación de un extremo a otro.
  4. Es una herramienta de compilación sencilla donde todas las configuraciones se pueden realizar utilizando un archivo XML y que se puede ejecutar desde la línea de comandos.
  5. Hace que su código esté limpio ya que la configuración está separada de la lógica de la aplicación real.

Cómo instalar hormiga

Pasos para instalar Ant en Windows es como sigue

Paso 1) Vaya al https://ant.apache.org/bindownload.cgi O descargar el archivo .zip desde apache-ant-1.9.4-bin.zip

Instalar hormiga

Paso 2) Descomprima la carpeta y vaya y copie la ruta a la raíz de la carpeta descomprimida.

Instalar hormiga

Paso 3) Vaya a Inicio -> Computadora -> haga clic derecho aquí y seleccione "Propiedades" y luego haga clic en Configuración avanzada del sistema

Instalar hormiga

Paso 4) Se abre una nueva ventana. Haga clic en el botón 'Variable de entorno...'.

Instalar hormiga

Paso 5) Haga clic en el botón 'Nuevo...' y establezca el nombre de la variable como 'ANT_HOME' y el valor de la variable como la ruta raíz a la carpeta descomprimida y haga clic en Aceptar.

Instalar hormiga

Paso 6) ahora seleccione la variable 'Ruta' de la lista y haga clic en 'Editar' y agregue; %ANT_HOME%\bin.

Instalar hormiga

Reinicie el sistema una vez y estará listo para usar la herramienta de compilación Ant ahora.

Paso 7) Para verificar la versión de su Ant usando la línea de comando:

Hormiga –versión

Instalar hormiga

Comprender Build.xml

Build.xml es el componente más importante de la herramienta de compilación Ant. Para Java proyecto, todas las tareas relacionadas con la limpieza, configuración, compilación e implementación se mencionan en este archivo en formato XML. Cuando ejecutamos este archivo XML usando la línea de comando o cualquier complemento IDE, todas las instrucciones escritas en este archivo se ejecutarán de manera secuencial.

Entendamos el código dentro de un build.XML de muestra.

  • La etiqueta de proyecto se utiliza para mencionar el nombre de un proyecto y el atributo de base. El basedir es el directorio raíz de una aplicación.
    <project name="YTMonetize" basedir=".">
  • Las etiquetas de propiedad se utilizan como variables en el archivo build.XML que se utilizarán en pasos posteriores.
<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 Etiquetas utilizadas como pasos que se ejecutarán en orden secuencial. El atributo de nombre es el nombre del objetivo. Puede tener varios objetivos en un solo build.xml.
    <target name="setClassPath">
  • La etiqueta de ruta se utiliza para agrupar lógicamente todos los archivos que se encuentran en la ubicación común.
    <path id="classpath_jars">
  • La etiqueta pathelement establecerá la ruta a la raíz de la ubicación común donde se almacenan todos los archivos.
    <pathelement path="${basedir}/"/>
  • etiqueta pathconvert utilizada para convertir rutas de todos los archivos comunes dentro de la etiqueta de ruta al formato de ruta de clase del sistema
    <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
  • etiqueta de conjunto de archivos utilizada para establecer classpath para diferentes archivos jar de terceros en nuestro proyecto
    <fileset dir="${ytoperation.dir}" includes="*.jar"/>
  • La etiqueta de eco se utiliza para imprimir texto en la consola.
<echo message="deleting existing build directory"/>
  • Eliminar etiqueta limpiará los datos de la carpeta dada
<delete dir="${build.dir}"/>
  • La etiqueta mkdir creará un nuevo directorio.
	<mkdir dir="${build.dir}"/>
  • Etiqueta javac utilizada para compilar el código fuente de Java y mover archivos .class a una nueva carpeta
        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>
  • La etiqueta jar creará un archivo jar a partir de archivos .class
	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
  • La etiqueta de manifiesto configurará su clase principal para su ejecución.
<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>
  • Atributo 'depende' utilizado para hacer que un objetivo dependa de otro objetivo
<target name="run" depends="compile">
  • La etiqueta Java ejecutará la función principal desde el jar creado en la sección de destino de compilación.
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Ejecute Ant usando Eclipse plugin

Para ejecutar Ant desde Eclipse, vaya al archivo build.xml -> haga clic derecho en el archivo -> Ejecutar como… -> haga clic en Archivo de compilación

Ejecute Ant usando Eclipse Plugin

Ejemplo

Tomaremos un pequeño programa de muestra que explicará muy claramente la funcionalidad de Ant. La estructura de nuestro proyecto se verá así:

Ejecute Ant usando Eclipse Plugin

Aquí en este ejemplo tenemos 4 objetivos.

  1. Establecer ruta de clase para frascos externos,
  2. Limpiar código previamente cumplido
  3. Compilar código java existente
  4. Ejecuta el código

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

Compilación.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>				

Ejecute Ant usando Eclipse plugin

Cómo ejecutar TestNG código usando Ant

Implementación TestNG código usando Ant

Aquí crearemos una clase con Prueba métodos y establecer la ruta de clase para Pruebas en build.xml.

Ahora, para ejecutar el método testng, crearemos otro archivo testng.xml y llamaremos a este archivo desde el archivo build.xml.

Paso 1) Creamos un "Guru99AntClass.class” en paquete pruebaHormiga

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

Paso 2) Cree un objetivo para cargar esta clase en 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>

Paso 3) Crear testng.xml

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

Paso 4) Crear Target en Build.xml para ejecutar esto TestNG código

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

Paso 5) El Build.xml completo

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

Paso 6) Resultado

Implementación TestNG código usando Ant

Descargue el archivo anterior

Con Ant a cargo de la construcción y TestNG Una vez conectado, el siguiente paso conecta Ant directamente a Selenium Controlador web.

hormiga con Selenium controlador web

Hasta ahora, hemos aprendido que con Ant podemos colocar todos los archivos JAR de terceros en una ubicación específica del sistema y definir su ruta para nuestro proyecto. Mediante este método, centralizamos todas las dependencias de nuestro proyecto, lo que mejora la fiabilidad de la compilación, la ejecución y el despliegue.

De manera similar, para nuestros proyectos de prueba que utilizan selenio, podemos mencionar fácilmente la dependencia de selenio en build.xml y no necesitamos agregar una ruta de clase manualmente en nuestra aplicación.

Así que ahora puedes ignorar la forma tradicional que se menciona a continuación de establecer rutas de clases para el proyecto.

hormiga con Selenium controlador web

Ejemplo:

Vamos a modificar el ejemplo anterior.

Paso 1) Establezca la propiedad selenium.jars en el jar relacionado con Selenium en la carpeta de recursos

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

Paso 2) En el setClassPath de destino, agregue los archivos de selenio

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

Paso 3) Compilación completa.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>

Paso 4) Ahora modifique la clase creada previamente. Guru99AntClass.java con código nuevo.

Aquí en este ejemplo nuestros pasos usando Selenium son:

  1. Vaya al https://demo.guru99.com/test/guru99home/
  2. Lea todos los enlaces de los cursos uno por uno.
  3. Imprima el hipervínculo de todos los cursos en la consola.

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

Paso 5) Después de una ejecución exitosa, la salida se verá así:

hormiga con Selenium controlador web

Descargue el archivo de ejemplo anterior

Preguntas Frecuentes

Ant es una herramienta de compilación procedimental donde se escribe cada paso manualmente, mientras que Maven es declarativa y gestiona las dependencias automáticamente a través de un repositorio central. Ant ofrece mayor control; Maven, convenciones.

Sí. Muchos legados Java y Selenium Los proyectos aún dependen de Ant para compilaciones e integración continua. Los proyectos más nuevos a menudo eligen Maven o Gradle, pero Ant sigue siendo útil para un control de compilación detallado.

Apache Ant 1.10.x es la serie que recibe mantenimiento activo y requiere Java 8 o posterior. La línea anterior 1.9.x admite versiones anteriores. JavaDescargue siempre los binarios desde el sitio web oficial ant.apache.org.

Sí. Los asistentes de IA como ChatGPT o Copilot generan los objetivos de build.xml, sugieren definiciones de tareas y explican los errores. RevExamine detenidamente el XML generado, ya que las rutas y las versiones de las dependencias aún necesitan verificación.

Las herramientas impulsadas por IA generan TestNG Los conjuntos de pruebas optimizan el orden de las pruebas y señalan las pruebas inestables activadas mediante objetivos Ant. Reducen el mantenimiento al sugerir correcciones en los localizadores y analizar automáticamente los informes de compilación.

No. Ant puede compilar y ejecutarse sin problemas. Java or JUnit pruebas también. TestNG Simplemente añade una configuración de suite flexible a través de testng.xml, que Ant invoca utilizando la tarea testng durante la compilación.

ANT_HOME le indica al sistema operativo dónde está instalado Ant para que el comando ant se ejecute desde cualquier directorio. Se agrega %ANT_HOME%\bin a la ruta del sistema durante la instalación. Windows.

Gradle Suele preferirse para proyectos nuevos porque combina la flexibilidad de Ant con la gestión de dependencias de Maven y compilaciones incrementales más rápidas. Elija Ant principalmente para el mantenimiento de scripts de compilación existentes.

Resumir este post con: