Ant es una utilidad para el desarrollo Java. Como en su propio faq dicen es algo así como un Make pero sin las “arrugas” de Make y con la portabilidad de ser código java puro.
En otras palabras, es una utilidad para compilar y comprobar el código Java mientras estás desarrollando. Después también, pero la gran utilidad es a la hora de desarrollar ya que te permite automatizar la tarea de compilar y ejecutar pruebas.
Ant viene por defecto en la mayoría de IDEs. Pero si quieres usarlo desde la linea de comando es tan fácil como:
apt-get install ant
Si quieres obtener la última versión de Ant tan sólo tienes que dirigirte al a página de descargas del proyecto Ant de Apache
Una vez instalado vamos a hacer un Hola mundo siguiendo las instrucciones que nos dan nuestros amigos de apache en su tutorial para ver como funciona.
Empecemos haciendo la aplicación Java:
mkdir holaMundo cd holaMundo mkdir -p src/net/juantxu/holaMundo
Una vez aquí vamos a hacer nuestra clase java dentro del directorio apropiado ( src/net/juantxu/holaMundo) ya que estará dentro del paquete net.juantxu.holaMundo. Para ello usaremos cualquier editor de texto:
vi src/net/juantxu/holaMundo/HolaMundo.java
y pondremos el código de nuestra clase:
package net.juantxu.holaMundo;
public class HolaMundo{
public static void main(String[] args) {
System.out.println("Hola Mundo");
}
}
Pues… ¡Vamos a probarlo! ¡A compilar, y ejecutar! Desde la raíz del directorio de trabajo que hemos creado al principio:
mkdir -p build/classes javac -sourcepath src -d build/classes src/net/juantxu/holaMundo/HolaMundo.java java -cp build/classes net.juantxu.holaMundo.HolaMundo
Y tenemos……
Hola Mundo
Pues visto que funciona… vamos a hacer el jar
echo Main-Class: net.juantxu.holaMundo.HolaMundo>miManifiesto mkdir build/jar jar cfm build/jar/HolaMundo.jar miManifiesto -C build/classes . java -jar build/jar/HolaMundo.jar
Tras terminar el paso previo de crear la aplicación java ahora debemos pensar en crear nuestro proceso. Hay que compliar el código para que nuestra aplicación pueda ejecutarse. Aunque ahora es una única clase imaginaremos que podría ser una aplicación súper compleja por lo que merece la pena hacer un jar. Igualmente será bueno limpiar el directorio de destino antes de empezar el proceso.
Por defecto ANT usa build.xml como nombre para el fichero constructor. Por lo que nosotros crearemos un fichero build.xml en la raiz de nuestro directorio de trabajo para especificar a ANT lo que debe de hacer.
vi build.xml
Y especificamo el contenido siguiente:
<project>
<target name="clean">
<delete dir="build"/>
</target>
<target name="compile">
<mkdir dir="build/classes"/>
<javac srcdir="src" destdir="build/classes"/>
</target>
<target name="jar">
<mkdir dir="build/jar"/>
<jar destfile="build/jar/HolaMundo.jar" basedir="build/classes">
<manifest>
<attribute name="Main-Class" value="net.juantxu.holaMundo.HolaMundo"/>
</manifest>
</jar>
</target>
<target name="run">
<java jar="build/jar/HolaMundo.jar" fork="true"/>
</target>
</project>
Ahora ya puedes compilar, empaquetar y ejecutar tu aplicacion.
ant compile ant jar ant run
O si lo prefieres en una sola línea:
ant compile jar run
y tenemos algo tal que así:
juantxu@apolonia:~/tmp/holaMundo$ ant compile jar run
Buildfile: build.xml
compile:
jar:
run:
[java] Hola Mundo
BUILD SUCCESSFUL
Total time: 5 seconds
Como puedes intuir para cada “target”, palabra clave que especificamos, le decimos lo que debe hacer.
Pero esta configuracion es un poco pobre, le tenemos que decir que compile, empaquete y ejecute. Eso se puede hacer mejor. Igualmente los directorios están especificados en cada caso, tambien se pueden usar variables para no tener que andar escribiendolos cada vez.
Mira este otro build.xml que está un poquito mejor hecho.
<project name="HolaMundo" basedir="." default="main">
<property name="src.dir" value="src"/>
<property name="build.dir" value="build"/>
<property name="classes.dir" value="${build.dir}/classes"/>
<property name="jar.dir" value="${build.dir}/jar"/>
<property name="main-class" value="net.juantxu.holaMundo.HolaMundo"/>
<target name="clean">
<delete dir="${build.dir}"/>
</target>
<target name="compile">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}"/>
</target>
<target name="jar" depends="compile">
<mkdir dir="${jar.dir}"/>
<jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
<manifest>
<attribute name="Main-Class" value="${main-class}"/>
</manifest>
</jar>
</target>
<target name="run" depends="jar">
<java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
</target>
<target name="clean-build" depends="clean,jar"/>
<target name="main" depends="clean,run"/>
</project>
Y volvemos a tener una salida tal que así:
juantxu@apolonia:~/tmp/holaMundo$ ant run
Buildfile: build.xml
compile:
jar:
run:
[java] Hola Mundo
BUILD SUCCESSFUL
Total time: 5 seconds
Todo el mundo sabe que un programa Java no es tan facil y simple. A poco que tengas que conectar a una base de datos o cualquier otra cosa necesitas añadir librerías (JARs). Y esas librerías deben estar incluidas tambien en el paquete que nosotros queremos crear.
- Pues nada mas facil! Se incluyen en el XML y listo! Para este ejemplo vamos a seguir las sugerencias de nuestros amiguos de Apache. Vamos a incluir las librerías de Log4J . Es una librería muy sencilla de usar y que nos permite manipular los logs de nuestra aplicación.
Empecemos modificando nuestra clase para usar la librería:
package net.juantxu.holaMundo;
import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;
public class HolaMundo{
static Logger logger = Logger.getLogger(HolaMundo.class);
public static void main(String[] args) {
BasicConfigurator.configure();
logger.info("Hola Mundo");
}
}
Y ahora vamos a comunicarselo a Ant. Como era de esperar se hace a través del build.xml que ya estabamos usando.
Se añade la la etiqueta relativa al directorio donde están los jars, las librerias
<property name="lib.dir" value="lib"/>
Se añade la etiqueta relativa a la inclusión de los jars en el classpath:
<path id="classpath">
<fileset dir="${lib.dir}" includes="**/*.jar"/>
</path>
Se añade la etiqueta relativa a la inclusión del contenido de dicho directorio en el classpath a la hora de ejecutar.
<target name="run" depends="jar">
<java fork="true" classname="${main-class}">
<classpath> <!-- aqui estoy indicandole que voy a retocar el classpath -->
<path refid="classpath"/>
<path location="${jar.dir}/${ant.project.name}.jar"/> <!-- el classpath contiene el directorio de los jars y el jar que creamos y vamos a ejecutar -->
</classpath>
</java>
</target>
Es lo mismo que si nosotros hicieramos:
java -classpath lib/log4j-1.2.15.jar:build/jar/HolaMundo.jar net.juantxu.holaMundo.HolaMundo
Al final nos queda un build.xml como este:
<project name="HolaMundo" basedir="." default="main">
<property name="src.dir" value="src"/>
<property name="build.dir" value="build"/>
<property name="classes.dir" value="${build.dir}/classes"/>
<property name="jar.dir" value="${build.dir}/jar"/>
<property name="lib.dir" value="lib"/>
<path id="classpath">
<fileset dir="${lib.dir}" includes="**/*.jar"/>
</path>
<property name="main-class" value="net.juantxu.holaMundo.HolaMundo"/>
<target name="clean">
<delete dir="${build.dir}"/>
</target>
<target name="compile">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
</target>
<target name="jar" depends="compile">
<mkdir dir="${jar.dir}"/>
<jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
<manifest>
<attribute name="Main-Class" value="${main-class}"/>
</manifest>
</jar>
</target>
<target name="run" depends="jar">
<java fork="true" classname="${main-class}">
<classpath>
<path refid="classpath"/>
<path location="${jar.dir}/${ant.project.name}.jar"/>
</classpath>
</java>
</target>
<target name="clean-build" depends="clean,jar"/>
<target name="main" depends="clean,run"/>
</project>