Ant Guía rápida

ANT son las siglas de Another Neat Tool. Es una herramienta de compilación basada en Java de Apache. Antes de entrar en los detalles de Apache Ant, primero comprendamos por qué necesitamos una herramienta de compilación en primer lugar.

Necesidad de una herramienta de construcción

En promedio, un desarrollador dedica una cantidad considerable de tiempo a realizar tareas mundanas como la compilación y la implementación, que incluyen:

  • Compilando el código
  • Empaquetando los binarios
  • Implementar los binarios en el servidor de prueba
  • Probando los cambios
  • Copiar el código de una ubicación a otra

Para automatizar y simplificar las tareas anteriores, Apache Ant es útil. Es una herramienta de implementación y compilación del sistema operativo que se puede ejecutar desde la línea de comandos.

Historia de Apache Ant

  • Ant fue creado por James Duncan Davidson (el autor original de Tomcat).

  • Originalmente se utilizó para construir Tomcat y se incluyó como parte de la distribución de Tomcat.

  • Ant nació de los problemas y complejidades asociados con la herramienta Apache Make.

  • Ant se promovió como un proyecto independiente en Apache en el año 2000. La última versión de Apache Ant en mayo de 2014 es 1.9.4.

Características de Apache Ant

  • Ant es la herramienta de implementación y compilación de Java más completa disponible.

  • Ant es una plataforma neutral y puede manejar propiedades específicas de la plataforma, como separadores de archivos.

  • Ant se puede utilizar para realizar tareas específicas de la plataforma, como modificar la hora de modificación de un archivo mediante el comando 'táctil'.

  • Los scripts de Ant se escriben utilizando XML plano. Si ya está familiarizado con XML, puede aprender Ant con bastante rapidez.

  • Ant es bueno para automatizar tareas repetitivas complicadas.

  • Ant viene con una gran lista de tareas predefinidas.

  • Ant proporciona una interfaz para desarrollar tareas personalizadas.

  • Ant se puede invocar fácilmente desde la línea de comandos y se puede integrar con IDE comerciales y gratuitos.

Apache Ant Ant se distribuye bajo la licencia de software Apache, una licencia de código abierto en toda regla certificada por la iniciativa de código abierto.

La última versión de Apache Ant, incluido su código fuente completo, archivos de clase y documentación, se puede encontrar en http://ant.apache.org.

Instalación de Apache Ant

Se asume que ya ha descargado e instalado Java Development Kit (JDK) en su computadora. Si no es así, siga las instrucciones aquí .

  • Asegúrese de que la variable de entorno JAVA_HOME esté configurada en la carpeta donde está instalado su JDK.

  • Descarga los binarios de http://ant.apache.org

  • Descomprima el archivo zip en una ubicación conveniente en la carpeta c: \. utilizando Winzip, winRAR, 7-zip o herramientas similares.

  • Cree una nueva variable de entorno llamada ANT_HOME que apunta a la carpeta de instalación de Ant, en este caso c:\apache-ant-1.8.2-bin carpeta.

  • Agregue la ruta del archivo por lotes Apache Ant a la variable de entorno PATH. En nuestro caso este sería elc:\apache-ant-1.8.2-bin\bin carpeta.

Verificación de la instalación de Apache Ant

Para verificar la instalación exitosa de Apache Ant en su computadora, escriba ant en el símbolo del sistema.

Debería ver una salida similar a:

C:\>ant -version
Apache Ant(TM) version 1.8.2 compiled on December 20 2010

Si no ve el resultado anterior, verifique que haya seguido los pasos de instalación correctamente.

Instalación de Eclipse

Este tutorial también cubre la integración de Ant con Eclipse IDE. Por lo tanto, si aún no ha instalado Eclipse, descargue e instale Eclipse

Para instalar Eclipse:

  • Descargue los binarios de Eclipse más recientes de www.eclipse.org

  • Descomprima los archivos binarios de Eclipse en una ubicación conveniente, diga c: \ carpeta

  • Ejecute Eclipse desde c: \ eclipse \ eclipse.exe

Normalmente, el archivo de compilación de Ant, llamado build.xmldebe residir en el directorio base del proyecto. Sin embargo, no existe ninguna restricción sobre el nombre del archivo o su ubicación. Puede utilizar otros nombres de archivo o guardar el archivo de compilación en otra ubicación.

Para este ejercicio, cree un archivo llamado build.xml en cualquier lugar de su computadora con el siguiente contenido:

<?xml version="1.0"?>
   <project name="Hello World Project" default="info">
   <target name="info">
      <echo>Hello World - Welcome to Apache Ant!</echo>
   </target>
</project>

Tenga en cuenta que no debe haber línea (s) en blanco o espacios en blanco antes de la declaración xml. Si los permite, aparece el siguiente mensaje de error al ejecutar la compilación de hormigas:

No se permite la coincidencia de destino de la instrucción de procesamiento "[xX] [mM] [lL]". Todos los archivos de compilación requierenproject elemento y al menos uno target elemento.

El elemento XML project tiene tres atributos:

Atributos Descripción
nombre El nombre del proyecto. (Opcional)
defecto El destino predeterminado del script de compilación. Un proyecto puede contener cualquier número de objetivos. Este atributo especifica qué destino debe considerarse como predeterminado. (Obligatorio)
basadoir El directorio base (o) la carpeta raíz del proyecto. (Opcional)

Un objetivo es una colección de tareas que desea ejecutar como una unidad. En nuestro ejemplo, tenemos un objetivo simple para proporcionar un mensaje informativo al usuario.

Los objetivos pueden tener dependencias de otros objetivos. Por ejemplo, undeploy el objetivo puede tener una dependencia del package objetivo, el package el objetivo puede tener una dependencia del compileobjetivo y así sucesivamente. Las dependencias se indican mediante ladependsatributo. Por ejemplo:

<target name="deploy" depends="package">
  ....
</target>
<target name="package" depends="clean,compile">
  ....
</target>
<target name="clean" >
  ....
</target>
<target name="compile" >
  ....
</target>

El elemento de destino tiene los siguientes atributos:

Atributos Descripción
nombre El nombre del objetivo (obligatorio)
depende Lista separada por comas de todos los destinos de los que depende este destino. (Opcional)
descripción Una breve descripción del objetivo. (Opcional)
Si Permite la ejecución de un objetivo en función de la veracidad de un atributo condicional. (Opcional)
a no ser que Agrega el destino a la lista de dependencias del punto de extensión especificado. Un punto de extensión es similar a un objetivo, pero no tiene ninguna tarea. (Opcional)

los echoLa tarea del ejemplo anterior es una tarea trivial que imprime un mensaje. En nuestro ejemplo, imprime el mensaje Hello World .

Para ejecutar el archivo de compilación ant, abra el símbolo del sistema y navegue hasta la carpeta donde reside build.xml, y escriba ant info. También puede escribiranten lugar. Ambos funcionarán, porqueinfoes el destino predeterminado en el archivo de compilación. Debería ver el siguiente resultado:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Hello World - Welcome to Apache Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

C:\>

Los archivos de compilación de Ant están escritos en XML, lo que no permite declarar variables como lo hace en su lenguaje de programación favorito. Sin embargo, como puede haber imaginado, sería útil si Ant permitiera declarar variables como el nombre del proyecto, el directorio de origen del proyecto, etc.

Ant usa el propertyelemento que le permite especificar propiedades. Esto permite cambiar las propiedades de una construcción a otra o de un entorno a otro.

De forma predeterminada, Ant proporciona las siguientes propiedades predefinidas que se pueden usar en el archivo de compilación:

Propiedades Descripción
archivo de hormiga La ubicación completa del archivo de compilación.
ant.version La versión de la instalación de Apache Ant.
basadoir La base de la compilación, como se especifica en el basedir atributo del project elemento.
ant.java.version La versión del JDK que usa Ant.
ant.project.name El nombre del proyecto, como se especifica en el name Atributo de la project elemento.
ant.project.default-target El destino predeterminado del proyecto actual.
ant.project.invoked-objetivos Lista separada por comas de los destinos que se invocaron en el proyecto actual.
ant.core.lib La ubicación completa del archivo jar de Ant.
hormiga hogar El directorio de inicio de la instalación de Ant.
ant.library.dir El directorio de inicio de los archivos de la biblioteca Ant, normalmente la carpeta ANT_HOME / lib.

Ant también hace que las propiedades del sistema (Ejemplo: file.separator) estén disponibles para el archivo de compilación.

Además de lo anterior, el usuario puede definir propiedades adicionales usando el propertyelemento. El siguiente ejemplo muestra cómo definir una propiedad llamadasitename:

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property name="sitename" value="www.tutorialspoint.com"/>
   <target name="info">
      <echo>Apache Ant version is ${ant.version} - You are 
         at ${sitename} </echo>
   </target>
</project>

Ejecutar Ant en el archivo de compilación anterior produce el siguiente resultado:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Apache Ant version is Apache Ant(TM) version 1.8.2  
      compiled on December 20 2010 - You are at www.tutorialspoint.com

BUILD SUCCESSFUL
Total time: 0 seconds
C:\>

Establecer propiedades directamente en el archivo de compilación está bien, si está trabajando con un puñado de propiedades. Sin embargo, para un proyecto grande, tiene sentido almacenar las propiedades en un archivo de propiedades separado.

Almacenar las propiedades en un archivo separado ofrece los siguientes beneficios:

  • Le permite reutilizar el mismo archivo de compilación, con diferentes configuraciones de propiedades para diferentes entornos de ejecución. Por ejemplo, el archivo de propiedades de compilación se puede mantener por separado para los entornos DEV, TEST y PROD.

  • Es útil cuando no conoce los valores de una propiedad (en un entorno particular) por adelantado. Esto le permite realizar la construcción en otros entornos donde se conoce el valor de la propiedad.

No existe una regla estricta y rápida, pero normalmente el archivo de propiedades se denomina build.properties y se coloca junto al build.xmlarchivo. Puede crear varios archivos de propiedades de compilación en función de los entornos de implementación, comobuild.properties.dev y build.properties.test.

El contenido del archivo de propiedades de compilación es similar al archivo de propiedades de Java normal. Contienen una propiedad por línea. Cada propiedad está representada por un nombre y un par de valores. Los pares de nombre y valor están separados por un signo igual (=). Se recomienda encarecidamente que las propiedades se anoten con los comentarios adecuados. Los comentarios se enumeran utilizando el carácter de almohadilla (#).

El siguiente ejemplo muestra un build.xml archivo y su asociado build.properties archivo:

build.xml

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property file="build.properties"/>
      <target name="info">
         <echo>Apache Ant version is ${ant.version} - You are 
            at ${sitename} </echo>
      </target>
</project>

build.properties

# The Site Name
sitename=www.tutorialspoint.com
buildversion=3.3.2

En el ejemplo anterior, sitenamees una propiedad personalizada que se asigna al nombre del sitio web. Puede declarar cualquier cantidad de propiedades personalizadas de esta manera. Otra propiedad personalizada enumerada en el ejemplo anterior es labuildversion, que, en este caso, se refiere a la versión de la compilación.

Además de lo anterior, Ant viene con una serie de propiedades de construcción predefinidas, que se enumeran en la sección anterior, pero que se representan a continuación una vez más.

Propiedades Descripción
archivo de hormiga La ubicación completa del archivo de compilación.
ant.version La versión de la instalación de Apache Ant.
basadoir La base de la compilación, como se especifica en el basedir atributo del project elemento.
ant.java.version La versión del JDK que usa Ant.
ant.project.name El nombre del proyecto, como se especifica en el name Atributo de la project elemento.
ant.project.default-target El destino predeterminado del proyecto actual.
ant.project.invoked-objetivos Lista separada por comas de los destinos que se invocaron en el proyecto actual.
ant.core.lib La ubicación completa del archivo jar de Ant.
hormiga hogar El directorio de inicio de la instalación de Ant.
ant.library.dir El directorio de inicio de los archivos de la biblioteca Ant, normalmente la carpeta ANT_HOME / lib.

El ejemplo presentado en este capítulo utiliza la ant.version propiedad incorporada.

Ant proporciona varios tipos de datos predefinidos. No confunda el término "tipos de datos" con los que están disponibles en el lenguaje de programación, en cambio considérelos como un conjunto de servicios que ya están integrados en el producto.

Apache Ant proporciona los siguientes tipos de datos.

Conjunto de archivos

Los tipos de datos del conjunto de archivos representan una colección de archivos. Se utiliza como filtro para incluir o excluir archivos que coinciden con un patrón en particular.

Por ejemplo, consulte el siguiente código. Aquí, el atributo src apunta a la carpeta de origen del proyecto.

El conjunto de archivos selecciona todos los archivos .java en la carpeta de origen, excepto los que contienen la palabra 'Stub'. El filtro que distingue entre mayúsculas y minúsculas se aplica al conjunto de archivos, lo que significa que un archivo con el nombre Samplestub.java no se excluirá del conjunto de archivos.

<fileset dir="${src}" casesensitive="yes">
   <include name="**/*.java"/>
   <exclude name="**/*Stub*"/>
</fileset>

Conjunto de patrones

Un conjunto de patrones es un patrón que permite filtrar archivos o carpetas fácilmente basándose en ciertos patrones. Los patrones se pueden crear utilizando los siguientes metacaracteres:

  • ? - Coincide con un solo carácter.

  • * - Coincide con cero o muchos caracteres.

  • ** - Coincide con cero o muchos directorios de forma recursiva.

El siguiente ejemplo muestra el uso de un conjunto de patrones.

<patternset id="java.files.without.stubs">
   <include name="src/**/*.java"/>
   <exclude name="src/**/*Stub*"/>
</patternset>

El conjunto de patrones se puede reutilizar con un conjunto de archivos de la siguiente manera:

<fileset dir="${src}" casesensitive="yes">
   <patternset refid="java.files.without.stubs"/>
</fileset>

Lista de archivos

El tipo de datos de la lista de archivos es similar al conjunto de archivos, excepto las siguientes diferencias:

  • filelist contiene listas de archivos con nombres explícitos y no admite comodines.

  • El tipo de datos de lista de archivos se puede aplicar a archivos existentes o no existentes.

Veamos el siguiente ejemplo del tipo de datos de lista de archivos. Aquí, el atributowebapp.src.folder apunta a la carpeta de origen de la aplicación web del proyecto.

<filelist id="config.files" dir="${webapp.src.folder}">
   <file name="applicationConfig.xml"/>
   <file name="faces-config.xml"/>
   <file name="web.xml"/>
   <file name="portlet.xml"/>
</filelist>

Conjunto de filtros

Al utilizar un tipo de datos de conjunto de filtros junto con la tarea de copia, puede reemplazar cierto texto en todos los archivos que coincida con el patrón con un valor de reemplazo.

Un ejemplo común es agregar el número de versión al archivo de notas de la versión, como se muestra en el siguiente código.

<copy todir="${output.dir}">
   <fileset dir="${releasenotes.dir}" includes="**/*.txt"/>
   <filterset>
      <filter token="VERSION" value="${current.version}"/>
   </filterset>
</copy>

En este Código:

  • El atributo output.dir apunta a la carpeta de salida del proyecto.

  • El atributo releasenotes.dir apunta a la carpeta de notas de la versión del proyecto.

  • El atributo current.version apunta a la carpeta de la versión actual del proyecto.

  • La tarea de copia, como su nombre indica, se utiliza para copiar archivos de una ubicación a otra.

Camino

los pathEl tipo de datos se usa comúnmente para representar una ruta de clase. Las entradas de la ruta se separan mediante punto y coma o dos puntos. Sin embargo, estos caracteres se reemplazan en el tiempo de ejecución por el carácter separador de ruta del sistema en ejecución.

La ruta de clase se establece en la lista de archivos jar y clases del proyecto, como se muestra en el siguiente ejemplo.

<path id="build.classpath.jar">
   <pathelement path="${env.J2EE_HOME}/${j2ee.jar}"/>
   <fileset dir="lib">
      <include name="**/*.jar"/>
   </fileset>
</path>

En este código:

  • El atributo env.J2EE_HOME apunta a la variable de entorno J2EE_HOME.

  • El atributo j2ee.jar apunta al nombre del archivo jar de J2EE en la carpeta base de J2EE.

Ahora que hemos aprendido sobre los tipos de datos en Ant, es hora de poner ese conocimiento en acción. Construiremos un proyecto en este capítulo. El objetivo de este capítulo es crear un archivo Ant que compile las clases java y las coloque en la carpeta WEB-INF \ classes.

Considere la siguiente estructura del proyecto:

  • Los scripts de la base de datos se almacenan en el db carpeta.

  • El código fuente de Java se almacena en el src carpeta.

  • Las imágenes, js, META-INF, estilos (css) se almacenan en el war carpeta.

  • Las JSP se almacenan en el jsp carpeta.

  • Los archivos jar de terceros se almacenan en el lib carpeta.

  • Los archivos de clases java se almacenan en el WEB-INF\classes carpeta.

Este proyecto forma el Hello World Solicitud por fax para el resto de este tutorial.

C:\work\FaxWebApplication>tree
Folder PATH listing
Volume serial number is 00740061 EC1C:ADB1
C:.
+---db
+---src
.  +---faxapp
.  +---dao
.  +---entity
.  +---util
.  +---web
+---war
   +---images
   +---js
   +---META-INF
   +---styles
   +---WEB-INF
      +---classes
      +---jsp
      +---lib

Aquí está el build.xml requerido para este proyecto. Considérelo pieza por pieza.

<?xml version="1.0"?>
<project name="fax" basedir="." default="build">
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>

   <target name="build" description="Compile source tree java files">
      <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" target="1.5">
         <src path="${src.dir}"/>
         <classpath refid="master-classpath"/>
      </javac>
   </target>
 
   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

Primero, declaremos algunas propiedades para las carpetas fuente, web y de compilación.

<property name="src.dir" value="src"/>
<property name="web.dir" value="war"/>
<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>

En este ejemplo:

  • src.dir se refiere a la carpeta de origen del proyecto donde se pueden encontrar los archivos de origen de Java.

  • web.dir se refiere a la carpeta de origen web del proyecto, donde puede encontrar JSP, web.xml, css, javascript y otros archivos relacionados con la web

  • build.dir se refiere a la carpeta de salida de la compilación del proyecto.

Las propiedades pueden hacer referencia a otras propiedades. Como se muestra en el ejemplo anterior, elbuild.dir propiedad hace una referencia a la web.dir propiedad.

En este ejemplo, el src.dir se refiere a la carpeta de origen del proyecto.

El objetivo predeterminado de nuestro proyecto es el compileobjetivo. Pero primero echemos un vistazo alclean objetivo.

El objetivo limpio, como sugiere el nombre, elimina los archivos de la carpeta de compilación.

<target name="clean" description="Clean output directories">
   <delete>
      <fileset dir="${build.dir}">
         <include name="**/*.class"/>
      </fileset>
   </delete>
</target>

El master-classpath contiene la información del classpath. En este caso, incluye las clases en la carpeta de compilación y los archivos jar en la carpeta lib.

<path id="master-classpath">
   <fileset dir="${web.dir}/WEB-INF/lib">
      <include name="*.jar"/>
   </fileset>
   <pathelement path="${build.dir}"/>
</path>

Finalmente, el objetivo de compilación para compilar los archivos. En primer lugar, creamos el directorio de compilación, si no existe. Luego ejecutamos el comando javac (especificando jdk1.5 como nuestra compilación de destino). Proporcionamos la carpeta de origen y la ruta de clase a la tarea javac y le pedimos que suelte los archivos de clase en la carpeta de compilación.

<target name="build" description="Compile main source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
</target>

Al ejecutar Ant en este archivo, se compilan los archivos fuente de Java y se colocan las clases en la carpeta de compilación.

El siguiente resultado es el resultado de ejecutar el archivo Ant:

C:\>ant
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

Los archivos se compilan y colocan en el build.dir carpeta.

La documentación es imprescindible en cualquier proyecto. La documentación juega un papel importante en el mantenimiento de un proyecto. Java facilita la documentación mediante el uso dejavadocherramienta. Ant lo hace aún más fácil al generar la documentación bajo demanda.

Como sabe, la herramienta javadoc es muy flexible y permite varias opciones de configuración. Ant expone estas opciones de configuración a través de la tarea javadoc. Si no está familiarizado con los javadocs, le sugerimos que comience con este Tutorial de documentación de Java .

La siguiente sección enumera las opciones de javadoc más comúnmente utilizadas en Ant.

Atributos

La fuente se puede especificar usando sourcepath, sourcepathref o sourcefiles.

  • sourcepath se utiliza para apuntar a la carpeta de los archivos de origen (por ejemplo, carpeta src).

  • sourcepathref se utiliza para hacer referencia a una ruta a la que hace referencia el atributo de ruta (por ejemplo, delegates.src.dir).

  • sourcefiles se utiliza cuando desea especificar los archivos individuales como una lista separada por comas.

La ruta de destino se especifica mediante el destdir carpeta (por ejemplo, build.dir).

Podrías filtrar el javadoctarea especificando los nombres de los paquetes que se incluirán. Esto se logra utilizando elpackagenames atributo, una lista separada por comas de archivos de paquetes.

Puede filtrar el proceso javadoc para mostrar solo las clases y miembros públicos, privados, de paquete o protegidos. Esto se logra utilizando elprivate, public, package y protected atributos.

También puede decirle a la tarea javadoc que incluya el autor y la información de la versión usando los atributos respectivos.

También puede agrupar los paquetes utilizando el group atributo, para que sea fácil de navegar.

Poniendolo todo junto

Continuemos nuestro tema del Hello worldSolicitud de fax. Agreguemos un objetivo de documentación a nuestro proyecto de aplicación de fax.

A continuación se muestra una tarea javadoc de ejemplo utilizada en nuestro proyecto. En este ejemplo, hemos especificado el javadoc para usar elsrc.dir como directorio de origen, y doc como el objetivo.

También hemos personalizado el título de la ventana, el encabezado y la información del pie de página que aparecen en las páginas de documentación de Java.

Además, hemos creado tres grupos:

  • uno para las clases de utilidad en nuestra carpeta de origen,
  • uno para las clases de interfaces de usuario, y
  • uno para las clases relacionadas con la base de datos.

Puede notar que el grupo de paquetes de datos tiene dos paquetes: faxapp.entity y faxapp.dao.

<target name="generate-javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[= Fax Application =]]></doctitle>
      <bottom>
         <![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   <echo message="java doc has been generated!" />
</target>

Ejecutemos la tarea Ant javadoc. Genera y coloca los archivos de documentación de Java en la carpeta doc.

Cuando el javadoc target se ejecuta, produce el siguiente resultado: 

C:\>ant generate-javadoc
Buildfile: C:\build.xml

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

Los archivos de documentación de Java ahora están presentes en el doc carpeta.

Normalmente, los archivos javadoc se generan como parte de los destinos de lanzamiento o paquete.

El siguiente paso lógico después de compilar sus archivos fuente de Java, es construir el archivo Java, es decir, el archivo JAR. Crear archivos JAR con Ant es bastante fácil con lajartarea. Los atributos de uso común de la tarea jar son los siguientes:

Atributos Descripción
basadoir El directorio base del archivo JAR de salida. De forma predeterminada, se establece en el directorio base del proyecto.
comprimir Aconseja a Ant que comprima el archivo mientras crea el archivo JAR.
mantener la compresión Mientras que la compress El atributo es aplicable a los archivos individuales, el keepcompression El atributo hace lo mismo, pero se aplica a todo el archivo.
destfile El nombre del archivo JAR de salida.
duplicar Aconseja a Ant sobre qué hacer cuando se encuentran archivos duplicados. Puede agregar, conservar o fallar los archivos duplicados.
excluye Aconseja a Ant que no incluya esta lista de archivos separados por comas en el paquete.
excludesfile Igual que el anterior, excepto que los archivos de exclusión se especifican mediante un patrón.
incluye Inverso de excluye.
incluye archivo Inverso de excludesfile.
actualizar Aconseja a Ant que sobrescriba archivos en el archivo JAR ya construido.

Continuando nuestro Hello WorldProyecto de aplicación de fax, agreguemos un nuevo objetivo para producir los archivos jar. Pero antes de eso, consideremos la tarea jar que se da a continuación.

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class"
/>

Aquí el web.dirpropiedad apunta a la ruta de los archivos de origen web. En nuestro caso, aquí es donde se colocará util.jar.

los build.dir La propiedad en este ejemplo apunta a la carpeta de compilación donde se pueden encontrar los archivos de clase para util.jar.

En este ejemplo, creamos un archivo jar llamado util.jar usando las clases del faxapp.util.*paquete. Sin embargo, excluimos las clases que terminan con el nombre Test. El archivo jar de salida se colocará en la carpeta lib de la aplicación web.

Si queremos que util.jar sea un archivo jar ejecutable, debemos agregar el manifest con el Main-Class meta atributo.

Por lo tanto, el ejemplo anterior se actualizará como:

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>

Para ejecutar la tarea jar, envuélvala dentro de un destino, más comúnmente, el destino de compilación o paquete, y ejecútelos.

<target name="build-jar">
<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>
</target>

Ejecutar Ant en este archivo crea el archivo util.jar para nosotros.

El siguiente resultado es el resultado de ejecutar el archivo Ant: 

C:\>ant build-jar
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 1.3 seconds

El archivo util.jar ahora se coloca en la carpeta de salida.

Crear archivos WAR con Ant es extremadamente simple y muy similar a la tarea de crear archivos JAR. Después de todo, el archivo WAR, como el archivo JAR, es solo otro archivo ZIP.

La tarea WAR es una extensión de la tarea JAR, pero tiene algunas adiciones agradables para manipular lo que entra en la carpeta WEB-INF / classes y generar el archivo web.xml. La tarea WAR es útil para especificar un diseño particular del archivo WAR.

Dado que la tarea WAR es una extensión de la tarea JAR, todos los atributos de la tarea JAR se aplican a la tarea WAR.

Atributos Descripción
webxml Ruta al archivo web.xml
lib Una agrupación para especificar qué va a la carpeta WEB-INF \ lib.
clases Una agrupación para especificar lo que entra en la carpeta WEB-INF \ classes.
metainf Especifica las instrucciones para generar el archivo MANIFEST.MF.

Continuando nuestro Hello WorldProyecto de aplicación de fax, agreguemos un nuevo objetivo para producir los archivos jar. Pero antes de eso, consideremos la tarea de la guerra. Considere el siguiente ejemplo:

<war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
</war>

Según los ejemplos anteriores, el web.dir variable se refiere a la carpeta web de origen, es decir, la carpeta que contiene los archivos JSP, css, javascript, etc.

los build.dirLa variable se refiere a la carpeta de salida: aquí es donde se pueden encontrar las clases para el paquete WAR. Normalmente, las clases se incluirán en la carpeta WEB-INF / classes del archivo WAR.

En este ejemplo, estamos creando un archivo war llamado fax.war. El archivo WEB.XML se obtiene de la carpeta de origen web. Todos los archivos de la carpeta 'WebContent' en web se copian en el archivo WAR.

La carpeta WEB-INF / lib se llena con los archivos jar de la carpeta thirdpartyjars. Sin embargo, estamos excluyendo portlet.jar ya que ya está presente en la carpeta lib del servidor de aplicaciones. Finalmente, estamos copiando todas las clases de la carpeta web del directorio de compilación y colocándolas en la carpeta WEB-INF / classes.

Envuelva la tarea de guerra dentro de un objetivo Ant (generalmente un paquete) y ejecútelo. Esto creará el archivo WAR en la ubicación especificada.

Es completamente posible anidar las clases, los directores de lib, metainf y webinf para que vivan en carpetas dispersas en cualquier parte de la estructura del proyecto. Pero las mejores prácticas sugieren que su proyecto web debe tener una estructura de contenido web similar a la estructura del archivo WAR. El proyecto de aplicación de fax tiene su estructura delineada utilizando este principio básico.

Para ejecutar la tarea de guerra, envuélvala dentro de un objetivo, más comúnmente, el objetivo de compilación o paquete, y ejecútelos.

<target name="build-war">
   <war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
   </war>
</target>

Ejecutar Ant en este archivo creará el fax.war archivo para nosotros.

El siguiente resultado es el resultado de ejecutar el archivo Ant: 

C:\>ant build-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 12.3 seconds

El archivo fax.war ahora se coloca en la carpeta de salida. El contenido del archivo war será:

fax.war:
   +---jsp             This folder contains the jsp files
   +---css             This folder contains the stylesheet files
   +---js              This folder contains the javascript files
   +---images          This folder contains the image files
   +---META-INF        This folder contains the Manifest.Mf
   +---WEB-INF
      +---classes   This folder contains the compiled classes
      +---lib       Third party libraries and the utility jar files
      WEB.xml       Configuration file that defines the WAR package

Hemos aprendido los diferentes aspectos de Ant utilizando el Hello World Aplicación web de fax en pedazos.

Ahora es el momento de poner todo junto para crear un archivo build.xml completo y completo. Considerarbuild.properties y build.xml archivos de la siguiente manera:

build.properties

deploy.path=c:\tomcat6\webapps

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
      <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
         destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application =</h1>]]>
      </doctitle>
      <bottom><![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/> 
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
      </javadoc>
   </target>

   <target name="usage">
      <echo message=""/>
      <echo message="${name} build file"/>
      <echo message="-----------------------------------"/>
      <echo message=""/>
      <echo message="Available targets are:"/>
      <echo message=""/>
      <echo message="deploy    --> Deploy application as directory"/>
      <echo message="deploywar --> Deploy application as a WAR file"/>
      <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" 
         target="1.5" debug="true"
         deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
      </javac>
   </target>

   <target name="deploy" depends="build" 
      description="Deploy application">
   <copy todir="${deploy.path}/${name}" 
      preservelastmodified="true">
      <fileset dir="${web.dir}">
         <include name="**/*.*"/>
      </fileset>
   </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

En este ejemplo:

  • Primero declaramos la ruta a la carpeta webapps en Tomcat en el archivo de propiedades de compilación como el deploy.path variable.

  • También declaramos la carpeta de origen de los archivos java en el src.dir variable.

  • Luego declaramos la carpeta de origen de los archivos web en el web.dir variable. javadoc.dir es la carpeta para almacenar la documentación de Java, y build.dir es la ruta para almacenar los archivos de salida de la compilación.

  • Luego declaramos el nombre de la aplicación web, que es fax en nuestro caso.

  • También definimos la ruta de la clase maestra que contiene los archivos JAR presentes en la carpeta WEB-INF / lib del proyecto.

  • También incluimos los archivos de clase presentes en el build.dir en el camino de la clase magistral.

  • El destino Javadoc produce el javadoc requerido para el proyecto y el destino de uso se utiliza para imprimir los destinos comunes que están presentes en el archivo de construcción.

El ejemplo anterior muestra dos objetivos de implementación: deploy y deploywar.

El destino de implementación copia los archivos del directorio web al directorio de implementación conservando la última marca de fecha y hora modificada. Esto es útil cuando se implementa en un servidor que admite la implementación en caliente.

El objetivo limpio borra todos los archivos creados previamente.

El destino deploywar crea el archivo war y luego copia el archivo war al directorio de implementación del servidor de aplicaciones.

En el capítulo anterior, aprendimos cómo empaquetar una aplicación e implementarla en una carpeta.

En este capítulo, implementaremos la aplicación web directamente en la carpeta de implementación del servidor de aplicaciones, luego agregaremos algunos destinos Ant para iniciar y detener los servicios. Sigamos con elHello Worldaplicación web de fax. Esta es una continuación del capítulo anterior, los nuevos componentes están resaltados en negrita.

build.properties

# Ant properties for building the springapp

appserver.home=c:\\install\\apache-tomcat-7.0.19
# for Tomcat 5 use $appserver.home}/server/lib
# for Tomcat 6 use $appserver.home}/lib
appserver.lib=${appserver.home}/lib

deploy.path=${appserver.home}/webapps

tomcat.manager.url=http://www.tutorialspoint.com:8080/manager
tomcat.manager.username=tutorialspoint
tomcat.manager.password=secret

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
   <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application 
         =</h1>]]></doctitle>
      <bottom><![CDATA[Copyright © 2011. All 
         Rights Reserved.]]></bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   </target>

   <target name="usage">
   <echo message=""/>
   <echo message="${name} build file"/>
   <echo message="-----------------------------------"/>
   <echo message=""/>
   <echo message="Available targets are:"/>
   <echo message=""/>
   <echo message="deploy    --> Deploy application as directory"/>
   <echo message="deploywar --> Deploy application as a WAR file"/>
   <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
   </target>

   <target name="deploy" depends="build" description="Deploy application">
      <copy todir="${deploy.path}/${name}" 
         preservelastmodified="true">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
<!-- ============================================================ -->
<!-- Tomcat tasks -->
<!-- ============================================================ -->

<path id="catalina-ant-classpath">
<!-- We need the Catalina jars for Tomcat -->
<!--  * for other app servers - check the docs -->
   <fileset dir="${appserver.lib}">
      <include name="catalina-ant.jar"/>
   </fileset>
</path>

<taskdef name="install" classname="org.apache.catalina.ant.InstallTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="list" classname="org.apache.catalina.ant.ListTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="start" classname="org.apache.catalina.ant.StartTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="stop" classname="org.apache.catalina.ant.StopTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>

<target name="reload" description="Reload application in Tomcat">
   <reload url="${tomcat.manager.url}"username="${tomcat.manager.username}"
      password="${tomcat.manager.password}" path="/${name}"/>
</target>
</project>

En este ejemplo, hemos utilizado Tomcat como nuestro servidor de aplicaciones. Primero, en el archivo de propiedades de construcción, hemos definido algunas propiedades adicionales.

  • los appserver.home apunta a la ruta de instalación del servidor de aplicaciones Tomcat.

  • los appserver.lib apunta a los archivos de la biblioteca en la carpeta de instalación de Tomcat.

  • los deploy.path La variable ahora apunta a la carpeta de la aplicación web en Tomcat.

Las aplicaciones en Tomcat se pueden detener e iniciar mediante la aplicación de administrador de Tomcat. La URL de la aplicación de administrador, el nombre de usuario y la contraseña también se especifican en el archivo build.properties. A continuación, declaramos un nuevo CLASSPATH que contiene elcatalina-ant.jar. Este archivo jar es necesario para ejecutar tareas de Tomcat a través de Apache Ant.

Catalina-ant.jar proporciona las siguientes tareas:

Propiedades Descripción
InstallTask Instala una aplicación web. Nombre de clase: org.apache.catalina.ant.InstallTask
ReloadTask Vuelva a cargar una aplicación web. Nombre de clase: org.apache.catalina.ant.ReloadTask
ListTask Muestra todas las aplicaciones web. Nombre de clase: org.apache.catalina.ant.ListTask
StartTask Inicia una aplicación web. Nombre de clase: org.apache.catalina.ant.StartTask
StopTask Detiene una aplicación web. Nombre de clase: org.apache.catalina.ant.StopTask
ReloadTask Recarga una aplicación web sin detenerse. Nombre de clase: org.apache.catalina.ant.ReloadTask

La tarea de recarga requiere los siguientes parámetros adicionales:

  • URL de la aplicación de administrador
  • Nombre de usuario para reiniciar la aplicación web
  • Contraseña para reiniciar la aplicación web
  • Nombre de la aplicación web que se reiniciará

Emitamos el deploy-warcomando para copiar la aplicación web a la carpeta de aplicaciones web de Tomcat y luego volver a cargar la aplicación web de fax. El siguiente resultado es el resultado de ejecutar el archivo Ant:

C:\>ant deploy-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

C:\>ant reload
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 3.1 seconds

Una vez que se ejecuta la tarea anterior, se implementa la aplicación web y se vuelve a cargar la aplicación web.

Puede utilizar Ant para ejecutar código Java. En el siguiente ejemplo, la clase java toma un argumento (dirección de correo electrónico del administrador) y envía un correo electrónico.

public class NotifyAdministrator
{
   public static void main(String[] args)
   {
      String email = args[0];
      notifyAdministratorviaEmail(email);
      System.out.println("Administrator "+email+" has been notified");
   }
   public static void notifyAdministratorviaEmail(String email
   { 
	   //......
   }
}

Aquí hay una compilación simple que ejecuta esta clase java.

<?xml version="1.0"?>
<project name="sample" basedir="." default="notify">
   <target name="notify">
      <java fork="true" failonerror="yes" classname="NotifyAdministrator">
         <arg line="[email protected]"/>
      </java>
   </target>
</project>

Cuando se ejecuta la compilación, produce el siguiente resultado: 

C:\>ant
Buildfile: C:\build.xml

notify: [java] Administrator [email protected] has been notified

BUILD SUCCESSFUL
Total time: 1 second

En este ejemplo, el código java hace una cosa simple: enviar un correo electrónico. Podríamos haber utilizado la tarea Ant incorporada para hacer eso. Sin embargo, ahora que tiene la idea, puede extender su archivo de compilación para llamar al código java que realiza cosas complicadas, por ejemplo: encripta su código fuente.

Si ya ha descargado e instalado Eclipse, tiene muy poco que hacer para comenzar. Eclipse viene incluido con el complemento Ant, listo para usar.

Siga los sencillos pasos para integrar Ant en Eclipse.

  • Asegúrese de que build.xml sea parte de su proyecto java y no resida en una ubicación externa al proyecto.

  • Habilite Ant View siguiendo Window > Show View > Other > Ant > Ant.

  • Abra el Explorador de proyectos, arrastre el archivo build.xml a la vista Ant.

Su vista de Ant es similar a:

Al hacer clic en los objetivos, build / clean / use ejecutará Ant con el objetivo.

Al hacer clic en "fax" se ejecutará el destino predeterminado: usage.

El complemento Ant Eclipse también viene con un buen editor para editar archivos build.xml. El editor conoce el esquema build.xml y puede ayudarlo a completar el código.

Para usar el editor Ant, haga clic derecho en su build.xml (desde el Explorador de proyectos) y seleccione Abrir con> Ant Editor. El editor de Ant debería tener un aspecto similar a:

El editor Ant enumera los objetivos en el lado derecho. La lista de objetivos sirve como marcador que le permite saltar directamente a la edición de un objetivo en particular.

JUnit es el marco de pruebas unitarias de uso común para desarrollos basados ​​en Java. Es fácil de usar y fácil de extender. Hay varias extensiones JUnit disponibles. Si no está familiarizado con JUnit, debe descargarlo de www.junit.org y leer su manual.

Este capítulo muestra cómo ejecutar pruebas JUnit usando Ant. Ant lo hace sencillo a través de la tarea JUnit.

Los atributos de la tarea JUnit se presentan a continuación:

Propiedades Descripción
dir Desde dónde invocar la VM. Esto se ignora cuandofork está desactivado.
jvm Comando utilizado para invocar la JVM. Esto se ignora cuandofork está desactivado.
tenedor Ejecuta la prueba en una JVM separada.
error de propiedad El nombre de la propiedad para establecer si hay un error JUnit
propiedad El nombre de la propiedad que se establecerá si hay un error de JUnit
haltonerror Detiene la ejecución cuando ocurre un error de prueba
haltonfailure Detiene la ejecución cuando ocurre una falla
resumen Aconseja a Ant que muestre estadísticas simples para cada prueba
showoutput Aconseja a Ant que envíe la salida a sus registros y formateadores
tempdir Ruta al archivo temporal que utilizará Ant
se acabó el tiempo Sale de las pruebas que tardan más en ejecutarse que esta configuración (en milisegundos).

Continuemos con el tema del Hello World Envíe por fax la aplicación web y agregue un destino JUnit.

El siguiente ejemplo muestra una ejecución de prueba JUnit simple:

<target name="unittest">
   <junit haltonfailure="true" printsummary="true">
      <test name="com.tutorialspoint.UtilsTest"/>
   </junit>
</target>

Este ejemplo muestra la ejecución de JUnit en la clase junit com.tutorialspoint.UtilsTest. La ejecución del código anterior produce el siguiente resultado:

test:
[echo] Testing the application
[junit] Running com.tutorialspoint.UtilsTest
[junit] Tests run: 12, Failures: 0, Errors: 0, Time elapsed: 16.2 sec
BUILD PASSED

Ant viene con un conjunto predefinido de tareas, sin embargo, puede crear sus propias tareas, como se muestra en el siguiente ejemplo.

Las tareas personalizadas de Ant deben extender el org.apache.tools.ant.Taskclass y debería extender el método execute (). A continuación se muestra un ejemplo simple:

package com.tutorialspoint.ant;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.BuildException;
public class MyTask extends Task {
   String message;
   public void execute() throws BuildException {
      log("Message: " + message, Project.MSG_INFO);
   }
   public void setMessage(String message) {
      this.message= message;
   }
}

Para ejecutar la tarea personalizada, debe agregar lo siguiente a la Hello World Aplicación web de fax:

<target name="custom">
   <taskdef name="custom" classname="com.tutorialspoint.ant.MyTask" />
   <custom message="Hello World!"/>
</target>

La ejecución de la tarea personalizada anterior imprime el mensaje '¡Hola mundo!'

c:\>ant custom
test:
[custom] Message : Hello World!
elapsed: 0.2 sec
BUILD PASSED

Este es solo un ejemplo simple, puede usar el poder de Ant para hacer lo que quiera para mejorar su proceso de construcción e implementación.

Impresión