How to use Ant, Maven2 and Scripting Languages together

I have used Ant tool to organize build process for a long period of time. It's pretty convenient and helps you to organize a lot of useful actions around compilation, packaging, deployment etc.

After some period of time I found that it is very convenient to use "script" task to extend basic functionality of Ant tool or dynamically customize it. For example, Javascript or Beanshell scripting languages are perfect selection for doing this.

The only one thing that Ant doesn't take care of is the project dependency resolution for libraries used within your project. Maven tool is especially designed to solve this problem.

As the result, the following architecture could cover all or the most of possible scenarios for describing build process: Ant + Maven + Some Scripting Language (Beanshell, Javascript, Groovy etc.)

Let me introduce basic steps that help you to solve the problem.


1. Ant tool should be aware of Maven. In order to achieve this, download "Maven Tasks for Ant library" (e.g. maven-artifact-ant-2.x.x-dep.jar) and install it into ${ant.home}/lib directory.


2. Once Maven Tasks for Ant are installed, we can start using them (in project.xml). First of all, describe the namespace for maven tasks:


<project name="myProject" default="run" basedir="."
         xmlns:artifact="antlib:org.apache.maven.artifact.ant">


3. Specify the location of your local Maven repository ("${repository.home}"). Usually it is ${user.home}/.m2, but you can choose any other location. Maven will download dependent libraries and save them inside this repository:

  <property name="repository.home" value="c:/local-maven-repository"/>

  <artifact:localRepository id="local.repository" location="${repository.home}" layout="default"/>


4. Load the Maven project file and assign some id for the project:


  <artifact:pom file="pom.xml" id="maven.project" />


5. Export various classpath variables from the Maven. In the following example we have access to compile-time, run-time and test-time classpath variables:


  <target name="resolve.dependencies">
    <artifact:dependencies pathId="compile.classpath" filesetId="compile.fileset" useScope="compile">
      <pom refid="maven.project"/>
    </artifact:dependencies>

    <artifact:dependencies pathId="runtime.classpath" filesetId="runtime.fileset" useScope="runtime">
      <pom refid="maven.project"/>
    </artifact:dependencies>

    <artifact:dependencies pathId="test.classpath" filesetId="test.fileset" useScope="test">
      <pom refid="maven.project"/>
    </artifact:dependencies>

  </target>


6. Now you can use Ant tasks/targets the same way as before. You don't need to build classpath manually, it will be built dynamically based on the information from "pom.xml" maven file.

You also should be aware of some commonly used properties inside Maven. For example:


${maven.project.build.sourceDirectory} -> src/main/java
${maven.project.build.directory} -> target
${maven.project.build.outputDirectory} -> target/classes
${maven.project.name} - the project name


You can find out other properties here: http://maven.apache.org/maven-model/maven.html.

Let's create basic Ant targets, like clean-compile-jar-run:


  <property name="jar.file" value="${maven.project.build.directory}/${maven.project.name}.jar"/>

  <target name="clean" description="Removes all compiled classes">
    <delete dir="${maven.project.build.directory}"/>
  </target>

   <target name="compile" depends="resolve.dependencies" description="Compiles java sources">
    <mkdir dir="${maven.project.build.outputDirectory}"/>

    <javac destdir="${maven.project.build.outputDirectory}"
           includeAntRuntime="false"
           debug="${debug}"
           optimize="${optimize}"
           deprecation ="${deprecation}">
        <classpath refid="compile.classpath"/>
        <src path="${maven.project.build.sourceDirectory}"/>
    </javac>
  </target>

  <target name="jar" depends="compile" description="Prepare packaging for the project">
    <jar destfile="${jar.file}">
      <fileset dir="${maven.project.build.outputDirectory}"/>
    </jar>
  </target>

  <target name="run" depends="jar">
    <java jar="${jar.file}" fork="true" failonerror="true" maxmemory="128m">
      <classpath>
        <path refid="runtime.classpath"/>
        <pathelement location="${jar.file}""/>
      </classpath>
     </java>
  </target>

  <target name="run.script">
    <script language="beanshell">
      print("Hello, World!");
    </script>
  </target>


7. Your dependencies for the project are expressed in the form of "pom.xml" maven file:

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>your.group.id</groupId>
  <artifactId>your.artifact.id</artifactId>
  <version>your.version</version>

  <name>YourName</name>

  <!-- Here you have to describe all your dependencies. -->
  <dependencies>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>

    ...
  </dependencies>

  </repositories>

</project>

By using this approach we can build scripts of any level of complexity without introducing Java compilation at all. Such programs will contain light-weight code, related to implementation only. All heavy-weight parts of the program will be conveniently located in the repository.