Groovy & Gradle: JVM Automation and Build Engineering · Lesson

Packaging JARs, WARs, EARs

Create various types of deployable artifacts (JAR, WAR, EAR) using Gradle's built-in plugins.

Packaging JARs, WARs, EARs is a free Groovy & Gradle: JVM Automation and Build Engineering lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Groovy & Gradle: JVM Automation and Build Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Packaging for Deployment

When you build an application, you need a way to package it for distribution and deployment. This is where deployable artifacts come in!

These are standardized packages like JARs, WARs, and EARs that bundle your application's code, resources, and dependencies. Gradle provides powerful, built-in plugins to create them efficiently.

Java Archives (JARs)

The most common artifact is a JAR (Java Archive). It's a standard format for packaging multiple Java class files, associated metadata, and resources into a single file.

JARs are typically used for:

Java libraries
Desktop applications
Command-line tools

Gradle's built-in java plugin automatically configures your project to produce a JAR file.

Basic JAR Creation

To create a basic JAR, you simply apply the java plugin in your build.gradle file. Gradle will automatically find your source code (usually in src/main/java) and build a JAR.

Here's a minimal build.gradle:

plugins {
    id 'java'
}

group 'com.coddykit'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

Making JARs Executable

For command-line applications, you often want an executable JAR. This means you can run it directly from your terminal using java -jar your-app.jar.

To achieve this, you need to configure the JAR's manifest file to specify which class contains your application's main method. You also typically bundle all project dependencies into this JAR.

Building an Executable JAR

Let's create a simple Java class that we'll package into an executable JAR. This class will have a main method.

Place this in src/main/java/com/coddykit/app/Greeter.java:

package com.coddykit.app;

public class Greeter {
    public String getGreeting() {
        return "Hello from CoddyKit!";
    }

    public static void main(String[] args) {
        System.out.println(new Greeter().getGreeting());
    }
}

Executable JAR Configuration

Now, let's configure build.gradle to make the previous Java code into an executable JAR. We specify the main class and include runtime dependencies.

After running gradle jar, you can execute it with java -jar build/libs/your-project-name-version.jar.

plugins {
    id 'java'
}

group 'com.coddykit'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

jar {
    manifest {
        attributes 'Main-Class': 'com.coddykit.app.Greeter'
    }
    // This bundles all runtime dependencies into the JAR
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
}

Web Application Archives (WARs)

A WAR (Web Application Archive) is a package specifically designed for web applications. It contains all the necessary components for a web application, such as:

Servlet classes
JSP files
HTML pages, CSS, JavaScript
Configuration files (e.g., web.xml)
Dependent JARs

WARs are typically deployed to a servlet container or application server (e.g., Tomcat, Jetty).

Using the `war` Plugin

To create a WAR file, you apply Gradle's built-in war plugin. This plugin automatically applies the java plugin and adds tasks to build WAR files according to the standard web application structure.

By default, web content (like HTML, CSS, JS) should be placed in src/main/webapp.

plugins {
    id 'war' // This implicitly applies the 'java' plugin
}

group 'com.coddykit'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    // Example: add a servlet API dependency for compilation
    providedCompile 'javax.servlet:javax.servlet-api:4.0.1'
}

war {
    archiveFileName = "my-web-app.war"
    // You can customize the webAppDirectory if needed
    // webAppDirectory = file('src/main/webroot')
}

Enterprise Archives (EARs)

An EAR (Enterprise Application Archive) is a package used to bundle multiple JARs and WARs into a single deployable unit. It's primarily used for larger Java EE (Enterprise Edition) applications deployed to full Java EE application servers (e.g., WildFly, WebLogic).

An EAR can contain:

One or more WAR modules (web applications)
One or more EJB-JAR modules (Enterprise JavaBeans)
Utility JARs (common libraries)

Using the `ear` Plugin

Gradle's ear plugin allows you to create EAR files. You declare which JARs and WARs should be included as modules within the EAR. This is often used in multi-project builds where subprojects produce the individual JARs and WARs.

The deploy configuration is used to add modules to the EAR.

plugins {
    id 'ear'
    id 'java' // For potential utility JARs within the EAR
    id 'war'  // For potential WARs within the EAR
}

group 'com.coddykit'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    // Example: Add a utility JAR and a WAR (e.g., from subprojects)
    // deploy project(':my-utility-jar')
    // deploy project(':my-web-app-war')

    // For this example, let's just make a dummy dependency
    deploy 'org.apache.commons:commons-lang3:3.12.0'
}

ear {
    archiveFileName = "my-enterprise-app.ear"
    // Optional: Customize application.xml (deployment descriptor)
    deploymentDescriptor {
        // applicationName = "MyEnterpriseApp"
    }
}

Artifact Type Check

Consider the different types of deployable artifacts and their primary use cases.

Recap: Packaging Artifacts

In this lesson, we explored how Gradle helps you package your applications into standard deployable artifacts:

JARs: For libraries and standalone Java applications, configured with the java plugin. You can make them executable by defining a Main-Class.
WARs: For web applications, using the war plugin and deployed to servlet containers.
EARs: For bundling multiple JARs and WARs in large enterprise applications, using the ear plugin.

Mastering these packaging techniques is crucial for effective deployment and distribution of your Java applications.

Frequently asked questions

Is the “Packaging JARs, WARs, EARs” lesson free?

Yes — the full text of “Packaging JARs, WARs, EARs” is free to read here on the web, and the Groovy & Gradle: JVM Automation and Build Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Groovy & Gradle: JVM Automation and Build Engineering course, upgrade to CoddyKit PRO.

What will I learn in “Packaging JARs, WARs, EARs”?

Create various types of deployable artifacts (JAR, WAR, EAR) using Gradle's built-in plugins. You practise Groovy & Gradle: JVM Automation and Build Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Groovy & Gradle: JVM Automation and Build Engineering?

No prior experience is required. Groovy & Gradle: JVM Automation and Build Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Packaging JARs, WARs, EARs” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Groovy & Gradle: JVM Automation and Build Engineering lesson?

Yes. Every Groovy & Gradle: JVM Automation and Build Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Groovy & Gradle: JVM Automation and Build Engineering