If you want reproducible Java builds but also like the idea of not being surprised at 2 a m by a broken pipeline, this guide uses Apache Ant and Jenkins to get you from source to artifact with minimal drama. We will verify tools, create a simple Ant build file, wire up a Jenkins job, archive artifacts, and run the job. Yes it is boring, and yes it works.

Verify your tools and environment

First prove to the computer that it has Java and Ant installed. Run these commands on the build agent or developer machine.

java -version
ant -version

Next confirm Jenkins is reachable at the host and port you expect. If Jenkins is hiding behind a reverse proxy, make friends with whoever set that up. If you have agents, make sure the agent user can run Ant and reach the Java compiler.

Create a minimal Ant build file

Keep the Ant build file simple. Put build.xml under source control with the rest of your code so it does not go missing between coffee breaks.

<project name="sample" default="jar" basedir=".">
  <target name="clean">
    <delete dir="build"/>
  </target>

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

  <target name="jar" depends="compile">
    <mkdir dir="dist"/>
    <jar destfile="dist/myapp.jar" basedir="build/classes"/>
  </target>
</project>

This gives you three obvious targets, clean, compile, and jar. The javac and jar tasks are the usual suspects for Java projects managed with Ant.

Create the Jenkins job

You have two main paths in Jenkins, a Freestyle project or a Pipeline job. Both work for CI automation with Ant.

Freestyle job quick setup

• New item, choose Freestyle project.
• Under source code management pick your repository and branch.
• Add a build step Execute Ant and use targets clean jar or just jar if you like living dangerously.
• In post build actions select Archive the artifacts and point to dist/*.jar so artifacts are kept.

Pipeline job example

If you prefer a Jenkinsfile in source control here is a compact Declarative Pipeline that runs Ant and archives the result.

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'ant clean jar'
      }
    }
  }
  post {
    always {
      archiveArtifacts 'dist/*.jar'
    }
  }
}

On Windows agents change the shell step to bat 'ant clean jar'. The pipeline keeps CI automation configuration next to your code which is a very good habit.

Add build steps and archive artifacts

Archiving artifacts means you can download the jar from Jenkins when someone says it worked on my machine. Configure post build actions in Freestyle jobs or the post block in Pipeline jobs to save your dist folder. Use environment variables in the job or Jenkinsfile to control version numbers or build modes across branches.

Run the job and inspect results

• Trigger a manual build or set up a webhook so pushes start builds automatically.
• Review the console output for compilation errors and dependency failures. The output tells you what went wrong, even when you do not want to know.
• Download the archived artifact and verify it runs or deploy it to the next stage of your CI pipeline.

Tips for less annoying CI

• Use a dedicated build user on Jenkins agents, so permissions do not turn into cryptic failures.
• Keep build.xml and Jenkinsfile under source control with your code for reproducible builds that do not depend on memory or luck.
• Pin tool versions where possible to avoid surprises when someone updates Ant or Java on the agent.

That is the gist of using Apache Ant with Jenkins to create reliable build jobs for Java projects. It is straightforward, it works, and it will save you time unless you enjoy late night debugging sessions. Now go make CI less dramatic.