Java Build and Packaging

This lesson covers the essentials of building a Java application: how source code becomes JVM bytecode, how to package applications for distribution, and how build automation tools streamline and standardize the process for projects of any size.

Simple build process

A minimal Java build has three steps:

Write source code (.java)
Compile to JVM bytecode (.class)
Run on a Java Virtual Machine (JVM)

Example source file:

// MyClass.java
public class MyClass {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Compile the source into bytecode:

javac MyClass.java

This produces MyClass.class. Run the program with the Java launcher (specify the class name without .class):

java MyClass
# Output:
# Hello World

You can inspect the JVM instructions (bytecode) with javap -c:

javap -c MyClass

Because JVM implementations exist for many platforms, Java bytecode is cross-platform: compile once, run anywhere that provides a compatible JVM.

Packaging: JAR and WAR

Applications typically include many classes plus resources (configuration, images, web assets). Packaging these into archives makes distribution and deployment simpler.

JAR (Java ARchive): Bundles class files, libraries, and resources into a single compressed archive.
WAR (Web ARchive): Layout for web applications; contains web-specific directories and static files.

Create a simple JAR by specifying the output file and files to include:

jar cf MyApp.jar MyClass.class Service1.class Service2.class

When creating a JAR, the jar tool generates a default META-INF/MANIFEST.MF. To make a JAR executable (so you can run java -jar MyApp.jar) you must include a Main-Class entry. Two common approaches:

Use the -e option to set the entry point:

jar cfe MyApp.jar MyClass MyClass.class Service1.class

Or provide a custom manifest file (e.g., manifest.txt):

Manifest-Version: 1.0
Created-By: 1.8.0_242 (Private Build)
Main-Class: MyClass

Include that manifest when building the JAR:

jar cfm MyApp.jar manifest.txt -C build/ .

Run the packaged JAR on any machine with a Java Runtime Environment (JRE):

java -jar MyApp.jar

If your application depends on external libraries, ensure they are available at runtime. Either use the Class-Path manifest entry, supply required JARs on the -cp/--class-path, or build a single “fat” or “uber” JAR that bundles dependencies.

Generating documentation

Document source with Javadoc. Running javadoc on source files generates an HTML documentation site:

javadoc -d doc MyClass.java

This creates an HTML site in the doc directory for other developers to browse.

When builds get bigger

Larger projects and team workflows typically require more steps:

Compiling multiple modules
Running unit and integration tests
Static analysis and linting
Security and vulnerability scanning
Packaging, signing artifacts, and publishing to artifact repositories

Manual command sequences become error-prone when projects grow or many developers contribute concurrently. Build automation tools provide repeatable, auditable, and CI/CD-friendly workflows.

A slide titled "Build Process" showing user and document icons on the left feeding through gears and package/build icons in the center to produce suitcase (artifact) icons and final documents on the right. Dotted lines connect the stages to illustrate a pipeline from source files to built outputs.

Build tools: Ant, Maven, Gradle

Common Java build tools let you describe build steps in configuration files and run them consistently across environments.

Tool	Approach	Typical use case
Ant	XML-based scripts with explicit targets	Fine-grained control; legacy projects
Maven	Convention-over-configuration (`pom.xml`) lifecycle	Dependency management and standardized project structure
Gradle	Groovy/Kotlin DSL, extensible plugin ecosystem	Modern builds, incremental builds, multi-module projects

Below is an example Ant build file that compiles code, generates Javadoc, and creates a JAR. Targets declare dependencies so Ant executes them in the required order.

<?xml version="1.0"?>
<project name="Ant" default="main" basedir=".">
    <!-- Compiles the java code -->
    <target name="compile">
        <javac srcdir="/app/src" destdir="/app/build" includeantruntime="false" />
    </target>

    <!-- Creates Javadoc (depends on compile) -->
    <target name="docs" depends="compile">
        <javadoc sourcepath="/app/src" destdir="/app/docs">
            <fileset dir="/app/src">
                <include name="**" />
            </fileset>
        </javadoc>
    </target>

    <!-- Creates the deployable .jar file (depends on compile) -->
    <target name="jar" depends="compile">
        <jar basedir="/app/build" destfile="/app/dist/MyApp.jar">
            <manifest>
                <attribute name="Main-Class" value="MyClass" />
            </manifest>
        </jar>
    </target>

    <!-- Main target: runs compile, jar, and docs -->
    <target name="main" depends="compile,jar,docs">
        <description>Main target</description>
    </target>
</project>

Run the default (main) target:

ant
# BUILD SUCCESSFUL
# Total time: 2 seconds

Or run specific targets, for example only compile and jar:

ant compile jar

Build tools let teams automate and standardize repetitive steps (compile, test, package, publish). Integrate these tools with CI/CD pipelines to enforce consistency and reduce manual errors.

Gradle example

A minimal Gradle build script (Groovy DSL) that applies plugins and defines the main class:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.bmuschko:gradle-docker-plugin:3.0.6'
    }
}

apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'com.bmuschko.docker-java-application'

mainClassName = 'MyClass'

Common Gradle commands:

Build the application:

./gradlew build

Run the application:

./gradlew run

Gradle offers a rich plugin ecosystem (Docker, publishing, test reporting) and is widely used for modern Java builds, multi-module projects, and CI environments.

Summary

Key takeaways:

Source (.java) -> compile with javac -> bytecode (.class) executed by the JVM.
Use the java launcher to run classes; use javadoc to generate API documentation.
Package applications into JAR/WAR archives; include a Main-Class manifest entry to make JARs executable.
Ensure external libraries are available at runtime via classpath entries or by creating a fat/uber JAR.
Use build tools (Ant, Maven, Gradle) to automate compilation, testing, packaging, and publishing in a repeatable way.

Introduction

Linux Basics

Networking Basics

Applications Basics

Source Control Management (SCM)

Web Server

Database Basics

Security

General Prerequisites

2 Tier Applications

Lab Setup

Conclusion

Java Build and Packaging

Simple build process

Packaging: JAR and WAR

Generating documentation

When builds get bigger

Build tools: Ant, Maven, Gradle

Gradle example

Summary

Watch Video

Practice Lab

​Simple build process

​Packaging: JAR and WAR

​Generating documentation

​When builds get bigger

​Build tools: Ant, Maven, Gradle

​Gradle example

​Summary

Watch Video

Practice Lab

Simple build process

Packaging: JAR and WAR

Generating documentation

When builds get bigger

Build tools: Ant, Maven, Gradle

Gradle example

Summary