Site icon CentLinux

How to install Apache ANT on CentOS 7

Alaric Bird
Share on Social Media

Learn step-by-step how to install Apache ANT on CentOS 7. Follow our comprehensive guide for a seamless installation process, ensuring you have all the necessary tools to get started with ANT on your CentOS system. #centlinux #linux #devops

What is Apache ANT?

Apache ANT (Another Neat Tool) is a Java Library and Command-line tool to automate software build processes. It is mostly used by open source community to compile and build Java applications. Apache ANT is platform independent. It uses a XML file build.xml to create script for the build process. The same build.xml file can be used on any platform to build the Java application.

Apache ANT (Another Neat Tool) is a Java-based build tool used for automating software build processes. It is similar to Make but is platform-independent and is mainly used for Java projects. ANT uses XML to describe the build process and its dependencies. Here are some key features of Apache ANT:

  1. Platform Independence: Written in Java, ANT can run on any platform that has a Java Virtual Machine (JVM).
  2. XML Configuration: Build files are written in XML, making them easy to understand and modify.
  3. Extensibility: Users can create their own tasks or extend existing ones, allowing for highly customizable build processes.
  4. Task-Based: The build process is divided into tasks, such as compiling code, copying files, generating JAR files, and running tests.
  5. Integration: ANT integrates well with various IDEs (Integrated Development Environments) and CI/CD (Continuous Integration/Continuous Deployment) tools.

Overall, Apache ANT is a powerful and flexible tool for automating repetitive tasks in the software development process, particularly for Java-based projects.

Apache ANT vs Apache Maven

Apache ANT and Apache Maven are both build automation tools commonly used in Java development, but they have distinct differences in their approach, configuration, and functionality. Here’s a comparison of the two:

Configuration Style

Dependency Management

Convention over Configuration

Build Lifecycle

Plugins and Extensibility

Use Cases

Learning Curve

Community and Ecosystem

Summary

Choosing between ANT and Maven depends on the specific needs of your project and your preference for build process control versus standardized project management.

Recommended Training for You: The Complete Apache Ant Bootcamp

Linux Server Specification

In this article, we will install Apache ANT on CentOS 7 machine and create a build.xml file to compile and build a simple Java application.

Apache ANT does not have any special system requirements. We are using a Linux machine with following specification.

Install Apache ANT on CentOS 7

Connect to ant-server.itlab.com using ssh.

Install Apache ANT package with yum command.

# yum install -y ant

Apache ANT requires Java Development Kit (JDK) therefore, it has installed the available version of OpenJDK from yum repository.

Create a Java Project

We will first create a simple Java application and then compile and build the JAR by using Java commands.

Let’s create required directory structure for our project.

# mkdir -p ~/TestApp/{src/test,build/classes,build/jar}

Here,

src/test directory is used for keeping the source code of our Java Application i.e. TestApp.
build/classes directory is used for place the compiled Java classes.
build/jar directory is used to generate JAR (Java Archive) from the compiled Java classes.

Check the directory structure.

# cd TestApp
# ls
build  src

Create a file in src/test directory.

# vi src/test/TestApp.java

and write some Java code here.

package test;

public class TestApp {
   public static void main(String[] args) {
      System.out.println("Testing Apache Ant...");
   }
}

Compile TestApp.java and check for any possible errors.

# javac -sourcepath src -d build/classes src/test/TestApp.java
# ls build/classes/
test
# ls build/classes/test/
TestApp.class

Our code has been successfully compiled.

Now, execute the compiled application.

# java -cp build/classes/ test.TestApp
Testing Apache Ant...

Since, our application is running fine, we can now create a JAR file from compiled classes.

To create a JAR, we need to create a JAR manifest for our Java Project.

# echo "Main-Class:test.TestApp" > mymanifest

Create a JAR file now.

# jar cvfm build/jar/test.jar mymanifest -C build/classes/ .
added manifest
adding: test/(in = 0) (out= 0)(stored 0%)
adding: test/TestApp.class(in = 434) (out= 299)(deflated 31%)

Execute JAR file.

# java -jar build/jar/test.jar
Testing Apache Ant...

We have successfully compiled our Java code and then build a JAR file by using Java commands.

Compile and Build with Apache ANT

Now, we will compile the same application by using ANT commands.

Create an ANT Build File build.xml for our project.

# vi build.xml

Define some basic Targets and Tasks therein.

<project default="run">

    <target name="clean">
        <delete dir="build" />
    </target>

    <target name="compile" depends="clean">
        <mkdir dir="build/classes" />
        <javac srcdir="src" destdir="build/classes" includeantruntime="yes" />
    </target>

    <target name="jar" depends="compile">
        <mkdir dir="build/jar" />
        <jar destfile="build/jar/test.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="test.TestApp" />
            </manifest>
        </jar>
    </target>

    <target name="run" depends="jar">
        <java jar="build/jar/test.jar" fork="true" />
    </target>

</project>

Run the Project using Apache ANT.

# ant
Buildfile: /root/TestApp/build.xml

clean:
   [delete] Deleting directory /root/TestApp/build

compile:
    [mkdir] Created dir: /root/TestApp/build/classes
    [javac] Compiling 1 source file to /root/TestApp/build/classes

jar:
    [mkdir] Created dir: /root/TestApp/build/jar
      [jar] Building jar: /root/TestApp/build/jar/test.jar

run:
     [java] Testing Apache Ant...

BUILD SUCCESSFUL
Total time: 1 second

We have successfully compiled and build our Java application by using ANT commands.

Here, we used a RHEL/CentOS 7 machine, but the same build.xml file can be used to compile and build our Java application on any other platform.

If you are new to Linux and facing difficulty in working at Linux Bash prompt. We recommend that, you should read The Linux Command Line, 2nd Edition: A Complete Introduction by William Shotts.

Final Thoughts

Installing Apache ANT on CentOS 7 is a straightforward process if you follow the right steps. By ensuring all dependencies are met and configuring your environment correctly, you can have ANT up and running in no time. Should you encounter any issues or need further assistance, feel free to reach out.

If you found this guide helpful and need additional support or personalized services for your projects, visit my Fiverr profile to check out my range of offerings. Whether it’s software installation, configuration, or troubleshooting, I’m here to help you achieve your goals efficiently and effectively.

Thank you for reading, and happy coding!

Exit mobile version