Choosing the Right Build Tool: Ant vs Maven vs Gradle

During software development, developers have to rebuild the same code over and over again. They often try to use bash scripts or other scripting languages to automate the task. However, there are build tools available that are more appropriate for build automation. The predominant build tools are:

• Apache Ant with Ivy
• Maven
• Gradle

Let’s investigate the tools to find out more.

Apache Ant with Ivy

Apache Ant is a Java-based command line tool that uses XML files to define build scripts. It’s predominantly used for Java builds but it can also be used for C/C++ development. Built-in tasks provide ways to compile, assemble, test and run software applications. Users can also create their own “antlibs” to enhance the functionality of Ant. Apache Ivy is a dependency management tool that integrates easily with Ant to provide a more robust ecosystem. The development of Ant started in 2000.

Pros

• Better control over the overall build process
• Flexible enough to work with any work process

Cons

• XML based build files can grow large and unmaintainable
• Lots of time and resources are necessary to maintain the build scripts
• IDE integration is difficult to achieve

Ant with Ivy Example

You can install the latest Ant from here. You have to download the zip, expand and put the bin folder in your path. You can use the following command to see if Ant is installed properly:

Once you have Ant installed, you can download the latest Ivy jar and put it in the lib folder inside the Ant directory.

After you have Ant installed, create folders helloworld and helloworld/src. Inside the src folder, put helloworld.java file with the code:

Now in the helloworld folder create a build.xml file with the following code:

And in the same helloworld folder, create the ivy.xml file with the following code:

The directory structure should look like this:

Now you can run the build with the command:

A successful build should provide output like this:

You can try out the jar file like this:

We have defined the jar file to be put in the build/bin folder. The folders get created during the build. The ant jar command calls the jar target in the build.xml.

Maven

Maven was developed to resolve the problems faced with Ant-based scripting. It kept the XML files but took a different approach to organization. In Ant, developers have to create all the tasks. Maven decreases the task creation by implementing stronger standards for organizing code. As a result, it’s easier to get started on standard projects.

It also introduced dependency downloads which made the development easier. Before the introduction of Ivy in Ant, users had to manage dependencies locally. Maven adopted the dependency management philosophy first.

However, Mavens strict standards make it difficult to write custom build scripts. The tool is easy to work with as long as the project follow the strict standards.

Pros

• Automatic dependency downloads
• All dependencies are automatically recorded in source control as part of the Maven scripts
• Standardizes and simplifies the build process
• Easily integrates with IDEs and CI/CD systems

Cons

• Not flexible in creating custom workflows
• Steep learning curve and the process is difficult for novices to understand
• Time-consuming to solve build problems and new library integrations
• Not good with multiple versions of the same dependency

Maven Example

You can download the latest Maven from here. You can check the installation like this:

Create a helloworld folder and generate a project with the following command:

It should create the folder structure and generate the output that looks like this:

The folder structure should look like this:

The pom.xml contains the build configurations. Inside the pom.xml the code looks like this:

You can generate the jar file using the following command:

You can run the jar file like this:

The jar file is put in the target folder.

Gradle

Gradle combines the power of Ant and Maven. The first version of Gradle was released in 2012. It has seen fast adoption. Google is currently using it for Android OS.

Instead of XML, Gradle uses the Groovy language. As a result, build scripts in Gradle are easier to write and read. It was initially using Ivy for dependency management, but it is using its own dependency engine now.

Pros

• Provides standardization while staying flexible
• Easy to read and write build scripts
• Better at handling multiple versions of dependencies
• Able to handle multiple programming languages and technologies
• Active community helping develop the tool
• Gradle DSL (Domain-Specific Language) makes it simple configuration structure
• Gradle provides performance improvements using incrementally, build cache and the Gradle Daemon

Cons

• IDE integration not as good as Maven

Gradle Example

You can install Gradle from here. Once you set up Gradle in your path, you can check it by:

Next, create the following directory structure:

For the helloworld.java put the code from the Ant example. And for build.gradle put in the following code:

You can use “gradle tasks –all” command to look at all the commands available. Gradle automatically picks up the plugins you specify in the build.gradle file and shows you the extra tasks available due to the plugins.

You can get the build by running:

You can run your jar like this:

The jar file is put in the build/libs folder.

Conclusion

Among the build tools, Ant can be useful for smaller projects while Maven is better for making sure all developers follow the same rules. Gradle is the latest tool that provides the most flexibility.

References:

• http://ant.apache.org/
• http://ant.apache.org/ivy/
• https://maven.apache.org/
• https://gradle.org/
• http://makble.com/gradle-junit-helloworld-example
• https://examples.javacodegeeks.com/core-java/gradle/gradle-hello-world-tutorial/
• https://gradle.org/maven-vs-gradle/
• https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html
• https://stackoverflow.com/questions/20755437/java-build-tools-ant-vs-maven
• https://technologyconversations.com/2014/06/18/build-tools/
• https://www.quora.com/What-are-the-pros-and-cons-of-Maven-versus-Ant-as-building-tools-for-Java