Java Ant tutorials

Java Ant Tutorial for beginner

2020-02-17T16:03:49-06:00

Throughout this Ant tutorial, I will walk you through the process of developing a Java project using Ant build, step by step. After finishing this lesson, you will be able to wrote Ant script for a standard build of a Java project. And based on that, you will be able to modify Ant build script of an existing project and customize the build process when needed.

To follow this tutorial, please use a text editor (Textpad or Sublime) with Command line prompt (on Windows) or Terminal (on Linux).

1. Download and setup Apache Ant

Go to https://ant.apache.org/bindownload.cgi to download the latest binary distribution of Apache Ant.

When I’m writing this, the latest release is Ant 1.10.7 which requires minimum of Java 8 at runtime. Download the apache-ant-1.10.7-bin.zip file and extract it on your hard drive. Then update the system environment variable PATH to include a path to apache-ant-1.10.7\bin directory. On Windows, you can type the following command in a Command Prompt window launched with administrator privilege:

setx -m PATH "%PATH%;apache-ant-1.10.8\bin"

Then open another command prompt, type ant -version and hit Enter. You should see the following output:

That means Apache Ant was installed successfully and ready to be used.

2. Code Java Project

We will code a Java program that inserts some contact information to a MySQL database. So create a new database schema named contactsdb with one table contact by executing the following MySQL statements (using either MySQL Workbench or MySQL Command Line Client):

CREATE DATABASE `contactsdb`;
CREATE TABLE `contacts` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `firstname` varchar(20) NOT NULL,
  `lastname` varchar(20) NOT NULL,
  `city` varchar(30) NOT NULL,
  `country` varchar(30) NOT NULL,
  PRIMARY KEY (`id`)
);

As you can see, the contacts table has 5 columns: id, firstname, lastname, city, and country.

Next, make a new directory for the project, called ContactManager. And under this project create src folder to store Java source files. And create the directory com\mycompany under src, for the package named com.mycompany. Then we have the following directory structure:

Now under mycompany, create a new Java source file named ContactInserter.java with the following code:

package com.mycompany;

import java.sql.*;

public class ContactInserter {
	public static void main(String[] args) {
		String url = "jdbc:mysql://localhost:3306/contactsdb?useSSL=false";
		String username = "root";
		String password = "password";
		String sql = "INSERT INTO contacts (firstname, lastname, city, country) VALUES (?, ?, ?, ?)";

		try {

			Connection connection = DriverManager.getConnection(url, username, password);
			PreparedStatement statement = connection.prepareStatement(sql);

			statement.setString(1, "Tom");
			statement.setString(2, "Eagar");
			statement.setString(3, "Chicago");
			statement.setString(4, "U.S.A");

			int rows = statement.executeUpdate();

			if (rows > 0) {
				System.out.println("A row was inserted.");
			} else {
				System.out.println("No row was inserted.");
			}

			connection.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}

	}
}

As you can see, this program simply connects to the database, inserts a row to the contacts table and then exits.

Next, you will see how to use Ant to compile, package and run this program.

3. Write Ant build script

Create the build.xml file under project’s root directory with the following XML code:

<project name="ContactProject" default="dist" basedir=".">

  <property name="src" location="src"/>
  <property name="build" location="build"/>
  <property name="dist" location="dist"/>

  <target name="init">
    <tstamp/>
    <mkdir dir="${build}"/>
  </target>

  <target name="compile" depends="init" description="compile the source">
    <javac srcdir="${src}" destdir="${build}"/>
  </target>

  <target name="dist" depends="compile" description="generate the distribution">
    <mkdir dir="${dist}"/>

    <jar jarfile="${dist}/ContactManager-${DSTAMP}.jar" basedir="${build}">
            <manifest>
                <attribute name="Main-Class" value="com.mycompany.ContactInserter"/>
            </manifest>    
    </jar>
  </target>

  <target name="clean" description="clean up">
    <delete dir="${build}"/>
    <delete dir="${dist}"/>
  </target>
</project>

This Ant build file contains 4 targets init, compile, dist and clean – similar to the one described in the previous lesson.

In the command line prompt, change the working directory to the project’s directory, and type ant command. You should see the following output:

Typing ant command without any arguments will execute the default target. In our build file, the default target is dist which depends on compile target which depends on init target. Hence these 3 targets are executed in the following order: init, compile and dist. The clean target was not executed because it is standalone.

Check the project’s directory and you see the build directory was created and the compiled .class files are put in, as a result of the compile target.

And the dist target created the dist directory and generate an executable JAR file in this directory. Now from the command line you can type the following command to run the program from JAR file:

java -jar dist\ContactManager-20191101.jar

And you will see this output:

It throws SQLException because no JDBC driver for MySQL found in the classpath.

Click here to download JDBC driver for MySQL. Download and extract the ZIP archive, e.g. mysql-connector-java-8.0.18.zip and you will see the JAR file named mysql-connector-java-8.0.18.jar.

Next, create a directory named lib under the project’s directory and copy the MySQL JDBC driver JAR file to it.

In the build.xml file, add two new properties:

<property name="lib" location="lib"/>
<property name="JdbcDriver" value="mysql-connector-java-8.0.18.jar"/>

In the <manifest> section, add a new attribute:

<attribute name="Class-Path" value="${JdbcDriver}"/>

This specifies the MySQL JDBC driver JAR file referenced by the executable JAR file. And add the <copy> task right after the <jar> task:

<copy file="${lib}\${JdbcDriver}" todir="${dist}" overwrite="true" />

This tells Ant to copy the MySQL JDBC driver JAR file to the distribution directory when the dist target is executed.

The complete build.xml file now looks like this:

<project name="ContactProject" default="dist" basedir=".">

  <property name="src" location="src"/>
  <property name="build" location="build"/>
  <property name="dist" location="dist"/>
  <property name="lib" location="lib"/>
  <property name="JdbcDriver" value="mysql-connector-java-8.0.18.jar"/>

  <target name="init">
    <tstamp/>
    <mkdir dir="${build}"/>
  </target>

  <target name="compile" depends="init" description="compile the source">
    <javac srcdir="${src}" destdir="${build}"/>
  </target>

  <target name="dist" depends="compile" description="generate the distribution">
    <mkdir dir="${dist}"/>

    <jar jarfile="${dist}/ContactManager-${DSTAMP}.jar" basedir="${build}">
            <manifest>
                <attribute name="Main-Class" value="com.mycompany.ContactInserter"/>
                <attribute name="Class-Path" value="${JdbcDriver}"/>
            </manifest>            
    </jar>
    
    <copy file="${lib}\${JdbcDriver}" todir="${dist}" overwrite="true" />
    
  </target>

  <target name="clean" description="clean up">
    <delete dir="${build}"/>
    <delete dir="${dist}"/>
  </target>
</project>

Now, type ant clean to delete everything the build and dist directories. You will see the following output:

Type ant again to rebuild the project. You will see the MySQL JDBC driver JAR file is copied to the dist directory, along with the generated executable JAR file of the program.

Now you can type the following command to run the program from the JAR file:

java -jar dist\ContactManager-20191101.jar

You will see the following output:

The program runs successfully and prints the message “A row was inserted”. You can check the database to confirm.

So each time you make changes to the code, you can run ant command to rebuild the project, conveniently.

That’s how to get started with Apache Ant – a popular build tool for Java projects. This lesson just scratches the surface, and Ant has more useful features which you can explore on Ant official homepage.

Introduction to Ant for beginner

2020-02-17T15:38:42-06:00

In this tutorial, you will learn about Apache Ant – one of most popular build tools for software development with Java. By the end of the tutorial, you will understand the role of Ant in developing Java projects and able to develop a simple Java project using Ant build. You will also know how IDEs like Eclipse, NetBeans and IntelliJ IDEA support Ant.

1. What is Ant?

Apache Ant is a Java library and command-line tool for automating software build processes. Imagine you are working on a Java project that contains many classes and the build process involves in compiling .java files to .class files, then packaging the compiled files to an executable JAR file. In each build, the name of the JAR file is suffixed by the current date time to track versions and releases. If you do this build process manually, you have to use javac command to compile, jar command to package and maybe an OS-dependent command to change the JAR file name.

That build process is repetitive and time-consuming if done manually. So you can automate the build process by creating an Ant build script that describes all the tasks need to be executed. Then you can use only a single Ant command to build the project, comfortably.

That’s basically how Ant works and the reason why we need to use it. But Ant is not limited to that, it is a powerful tool that can be used to automate any type of process which can be described in terms of targets and tasks (a target contains a set of tasks).

2. A Brief History of Ant

Ant was created by James Ducan Davidson in early 2000 when he was working on the Apache Tomcat project. James was creating Tomcat’s builds for different operating systems and he found that there’s no cross-platform build tools he can use. He used the Make build tool on Unix, but on Windows he had to write different build script. So James wrote Ant in pure Java code as a replacement to Make.

Soon thereafter, Ant was used by several open source Java projects and spread like a virus. It became an independent project managed by the Apache Software Foundation – hence the official name Apache Ant. The name Ant is an acronym for “Another Neat Tool” – according to its original author James Duncan Davidson.

The first official release of Ant was Ant 1.1, released on 19 July 2000, and the latest version (at the time of this writing) is Ant 1.10.7 released on 5 Sep 2019.

Today Ant is the build tool of choice for a lot of projects, and it is the default build tool in NetBeans IDE (version 8.2 and older).

3. A Sample Ant Build script

Let’s look at a typical Ant build script to learn more. The default Ant build file name is build.xml which is usually placed in the project’s root directory. Following is the code of a sample Ant build script for a Java project:

<project name="MyProject" default="dist" basedir=".">

  <!-- set global properties for this build -->
  <property name="src" location="src"/>
  <property name="build" location="build"/>
  <property name="dist" location="dist"/>

  <target name="init">
    <!-- Create the time stamp -->
    <tstamp/>
    <!-- Create the build directory structure used by compile -->
    <mkdir dir="${build}"/>
  </target>

  <target name="compile" depends="init"
        description="compile the source">
    <!-- Compile the java code from ${src} into ${build} -->
    <javac srcdir="${src}" destdir="${build}"/>
  </target>

  <target name="dist" depends="compile"
        description="generate the distribution">
    <!-- Create the distribution directory -->
    <mkdir dir="${dist}/lib"/>

    <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
    <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}">
            <manifest>
                <attribute name="Main-Class" value="net.codejava.HelloAnt"/>
            </manifest>    
    </jar>
  </target>

  <target name="clean"
        description="clean up">
    <!-- Delete the ${build} and ${dist} directory trees -->
    <delete dir="${build}"/>
    <delete dir="${dist}"/>
  </target>
</project>

As you can see, we use XML to describe the build process in terms of targets and tasks. There are 4 targets defined in this build file: init, compile, dist and clean. When you run an Ant build, the default target will be executed.

In this project, the default target is dist:

<project name="MyProject" default="dist" basedir=".">

Look at the description of the dist target, you will see it depends on the compile target:

 <target name="dist" depends="compile”…>

In turn, the compile target depends on the init target:

<target name="compile" depends="init"…>

So the sequence of execution is init, compile and dist. The init target initializes resources for the build, e.g. create a timestamp and make the build directory. It is done using the tstamp and mkdir tasks:

<target name="init">
  <tstamp/>
  <mkdir dir="${build}"/>
</target>

Then the compile target compiles all Java source files and put the compile .class files to the build directory, using the javac task:

<target name="compile" depends="init">
  <javac srcdir="${src}" destdir="${build}"/>
</target>

And finally the dist target generates an executable JAR file and put it into the distribution directory dist/lib. It is done using the mkdir and jar tasks:

<target name="dist" depends="compile">
  <mkdir dir="${dist}/lib"/>

  <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}">
          <manifest>
              <attribute name="Main-Class" value="net.codejava.HelloAnt"/>
          </manifest>    
  </jar>
</target>

That’s the execution flow of this build file. And you can notice that the clean target doesn’t depend on any targets, which means it will run standalone if requested.

From the command line prompt, just type ant run the build starting from the default target. And you would see the following output:

You can also type ant <target> to run a specific target, for example:

This executes the clean target that deletes everything in the build and dist directories.

You can reuse this sample build.xml file for any Java project.

4. Benefits of using Ant

Ant helps automating the build process so you can save time and effort when developing Java projects using Ant build. You can avoid doing repetitive tasks manually, which is boring and time-consuming.

In addition, Ant is written in pure Java code so you can reuse Ant build files across platforms.

5. Drawbacks of using Ant

Ant build files, which are written in XML, can be complex and verbose when the project becomes complex and large. Ant doesn’t directly support dependency management (automatic download and management of library JAR files), though you can do it using Apache Ivy, which requires longer learning curve.

6. Ant supported by IDEs

NetBeans IDE versions 8.2 and older uses Ant as the default build for its projects. From newer versions (Apache NetBeans), it allows programmers to explicitly choose a build tool for new projects (Ant, Maven or Gradle). Eclipse and IntelliJ IDEA allow you to generate Ant build files for projects.

And all these IDEs support code completion and suggestion for Ant build files, which allows you to write Ant script easily.

To learn more, visit Apache Ant homepage.