Alejandro es socio fundador de Autentia y nuestro experto en J2EE, Linux y optimización de aplicaciones empresariales.

Ingeniero en Informática y Certified ScrumMaster

Seguir @alejandropgarci

Si te gusta lo que ves, puedes contratarle para darte ayuda con soporte experto, impartir cursos presenciales en tu empresa o para que realicemos tus proyectos como factoría (Madrid).
Puedes encontrarme en Autentia: Ofrecemos servicios de soporte a desarrollo, factoría y formación.

Ver todos los tutoriales del autor

Fecha de publicación del tutorial: 2008-01-17

Tutorial visitado 11.924 veces Descargar en PDF

RMI y como registrar objetos en un Registry remoto

Como integrar tareas Ant en Maven

Creación: 13-01-2008

Índice de contenidos

1. Introducción
2. Entorno
3. Configurando el pom.xml
4. Generando un archivo EAR usando Ant
5. Conclusiones
6. Sobre el autor

1. Introducción

Ya hemos visto varios tutoriales de Maven, y hemos vistos que con Maven podemos hacer muuuuuchas cosas. Sin embargo siempre encontraremos alguna tarea que no es capaz de hacer (por ejemplo en el campo de la generación de código, donde Maven está más flojo).

En estas ocasiones podemos desarrollar un plugin de Maven (Javier Antoniucci ya nos contó como en http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=PluginsMaven). Otra opción sería llamar a tareas de Ant (http://ant.apache.org/) para hacer lo que necesitamos.

En este tutorial vamos a explorar un poco la segunda opción, viendo como podemos, desde nuestro pom.xml, invocar tareas de Ant.

Otro motivo muy interesante por el cual nos puede interesar invocar tareas de Ant desde el pom.xml, es para migrar poco a poco proyectos que actualmente tenemos con Ant, a Maven.

2. Entorno

El tutorial está escrito usando el siguiente entorno:

Hardware: Portátil Asus G1 (Core 2 Duo a 2.1 GHz, 2048 MB RAM, 120 GB HD).
Sistema Operativo: GNU / Linux, Debian (unstable), Kernel 2.6.23, KDE 3.5
JDK 1.5.0_13 (instalada con el paquete sun-java5-jdk de Debian)
Maven 2.0.8
Ant 1.7.0

3. Configurando el pom.xml

Para ejecutar tareas de Ant en nuestro pom.xml basta con configurar el plugin maven-antrun-plugin (http://maven.apache.org/plugins/maven-antrun-plugin/):

<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>

Vamos a ver un ejemplo sencillo (sacado de la propia documentación del plugin):

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	
    <modelVersion>4.0.0</modelVersion>
    <groupId>my-test-group</groupId>
    <artifactId>my-test-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <executions>
                    <execution>
                        <id>show-classpaths</id>
                        <phase>compile</phase>
                        <configuration>
                            <tasks>
                                <property name="compile_classpath" refid="maven.compile.classpath" />
                                <property name="runtime_classpath" refid="maven.runtime.classpath" />
                                <property name="test_classpath" refid="maven.test.classpath" />
                                <property name="plugin_classpath" refid="maven.plugin.classpath" />

                                <echo message="compile classpath: ${compile_classpath}" />
                                <echo message="runtime classpath: ${runtime_classpath}" />
                                <echo message="test classpath:    ${test_classpath}" />
                                <echo message="plugin classpath:  ${plugin_classpath}" />
                            </tasks>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
    </build>
</project>

Como al configurar cualquier plugin de Maven, con <goal> le indicamos que objetivo del plugin queremos ejecutar, en este caso el run. Y con <phase> indicamos en que fase del ciclo de vida de Maven queremos hacer la ejecución.

Lo interesante es lo que tenemos en el elemento <tasks>, aquí estamos escribiendo directamente tareas de Ant. En el ejemplo vemos como asignamos a propiedades los distintos classpath, y luego los mostramos por consola.

Si bien esto es posible, no es muy recomendable, ya que el pom.xml queda muy “cargado”. Es mejor tener nuestras tareas de Ant en un build.xml e invocar a este con la tarea de Ant <ant>. En el apartado siguiente veremos un ejemplo de esto.

4. Generando un archivo EAR usando Ant

Ahora vamos a ver un ejemplo de como generar un archivo EAR usando un script en Ant. Ojo, esto es sólo un ejemplo de como integrar scripts de Ant con Maven, si queremos generar un archivo EAR desde Maven, es más interesante usar el plugin maven-ear-plugin (http://maven.apache.org/plugins/maven-ear-plugin/index.html).

Volvamos al ejemplo:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.autentia.tutorial</groupId>
    <artifactId>ant-example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <executions>
                    <execution>
                        <id>package-ear</id>
                        <phase>package</phase>
                        <configuration>
                            <tasks>
                                <ant target="ear" inheritRefs="true">
                                    <property name="artifactId" value="${artifactId}" />
                                    <property name="version" value="${version}" />
                                    <property name="classifier" value="" />
                                </ant>
                            </tasks>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
    </build>
</project>

En este ejemplo podemos ver como estamos invocando el target ear de nuestro script build.xml (no es necesario especificar el nombre del fichero porque build.xml es la opción por defecto). También podemos ver como le podemos pasar parámetros a nuestro script de Ant.

Ahora mostramos como sería el script build.xml:

<?xml version="1.0"?>
<project name="build-project" default="ear" basedir=".">

    <property environment="env" />

    <target name="ear" description="Make a ear archive with the corresponding war.">
        <copy file="target/${artifactId}-${version}${classifier}.war" tofile="target/${artifactId}.war" />
		
        <ear destfile="target/${artifactId}-${version}${classifier}.ear"
            basedir="target"
            includes="${artifactId}.war"
            appxml="src/main/webapp/META-INF/application.xml"
        >
        </ear>
	
        <delete file="target/${artifactId}.war" />
    </target>
</project>

5. Conclusiones

Con estos sencillos ejemplos hemos visto como podemos aumentar la potencia de Maven, llamando a scripts de Ant.

Antes de terminar lo que si os quiero aconsejar es que no abuséis de esta técnica, Maven ya tiene multitud de plugins para hacer prácticamente de todo; así que os recomiendo que, aunque tengáis experiencia con Ant y estéis empezando con Maven, os deis una vuelta por http://maven.apache.org/plugins/.

Usar directamente los plugins de Maven siempre os va a ofrecer más ventajas, ya que se integran con todo el ciclo de vida de Maven. Por ejemplo, en el ejemplo que hemos visto antes en el que generamos un archivo EAR, este archivo no se instalará en nuestro repositorio local al hacer mvn install, ni en el remoto al hacer mvn deploy.