Run an Ant Task with Maven

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

In distributed systems, managing multi-step processes (e.g., validating a driver, calculating fares, notifying users) can be difficult. We need to manage state, scattered retry logic, and maintain context when services fail.

Dapr Workflows solves this via Durable Execution which includes automatic state persistence, replaying workflows after failures and built-in resilience through retries, timeouts and error handling.

In this tutorial, we'll see how to orchestrate a multi-step flow for a ride-hailing application by integrating Dapr Workflows and Spring Boot:

>> Dapr Workflows With PubSub

1. Introduction

Maven and Ant are both well-known build automation tools for Java. Although most of the time we’ll only use one of these, there are cases when using the two together makes sense.

A common use case is when working on a legacy project that uses Ant, and we want to introduce Maven gradually while still keeping some existing Ant tasks in place.

In this tutorial, we’ll cover how to do this using the Maven AntRun Plugin.

**2. Maven AntRun Plugin**

Maven AntRun Plugin allows us to run Ant tasks within Maven.

2.1. Adding the Plugin

To use this plugin, we need to add it to our Maven project’s build plugins:

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

The latest plugin version can be found on the Maven Central (although it hasn’t been updated in a long time).

2.2. Plugin Executions

As with any other Maven plugin, to make use of AntRun plugin, we need to define executions.

In the example below, we’re defining one execution tied to Maven’s package phase, which will zip the final JAR file from the project’s target directory:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>1.8</version>
    <executions>
        <execution>
            <id>zip-artifacts</id>
            <phase>package</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <zip destfile="${project.basedir}/package.zip" 
                       basedir="${project.build.directory}" 
                       includes="*.jar" />
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

To execute the plugin, we run the command:

mvn package

Since we declared our plugin to run during Maven’s package phase, running Maven’s package goal will execute our plugin configuration above.

**3. Example Using build.xml File**

Aside from allowing us to define Ant targets in plugin configuration, we can also use an existing Ant build.xml file.

3.1. build.xml

Below is an example of a project’s Ant build.xml file with a target defined to upload zip files from the project’s base directory to an FTP server:

<project name="MyProject" default="dist" basedir=".">
   <description>Project Description</description>

   ...
   
    <target name="ftpArtifact">
        <ftp 
          server="${ftp.host}" 
          userid="${ftp.user}" 
          password="${ftp.password}">
            <fileset dir="${project.basedir}>
                <include name="**/*.zip" />
            </fileset>
        </ftp>
    </target>
</project>

3.2. Plugin Configuration

To use the above build.xml file, we define the execution in our plugin declaration:

<execution>
    <id>deploy-artifact</id>
    <phase>install</phase>
    <goals>
        <goal>run</goal>
    </goals>
    <configuration>
        <target>
            <ant antfile="${basedir}/build.xml">
                <target name="ftpArtifact"/>
            </ant>
        </target>
    </configuration>
</execution>

Since the ftp task isn’t included in ant.jar, we need to add Ant’s optional dependencies to our plugin configuration:

<plugin>
    <executions>
       ...
    </executions>
    <dependencies>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>1.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.ant</groupId>
            <artifactId>ant-commons-net</artifactId>
            <version>1.8.1</version>
        </dependency>
    </dependencies>
</plugin>

To execute the plugin, we run the command:

mvn install

4. Conclusion

In this short article, we’ve discussed running Ant tasks with Maven’s AntRun plugin. Even though it’s a very simple plugin, having only one goal, this plugin can prove to be effective in projects and teams that prefer the use of Ant for specific build instructions.

And, if you want to learn more about Ant and Maven, you can read our article, comparing these two – along with Gradle.