Groovy & Gradle: JVM Automation and Build Engineering · Pelajaran

Mengemas JAR, WAR, EAR

Buat berbagai tipe artefak yang dapat diterapkan (JAR, WAR, EAR) menggunakan plugin bawaan Gradle.

Mengemas JAR, WAR, EAR adalah pelajaran Groovy & Gradle: JVM Automation and Build Engineering gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Groovy & Gradle: JVM Automation and Build Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengemas JAR, WAR, EAR” gratis?

Ya — teks lengkap “Mengemas JAR, WAR, EAR” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Groovy & Gradle: JVM Automation and Build Engineering, upgrade ke CoddyKit PRO. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengemas JAR, WAR, EAR”?

Buat berbagai tipe artefak yang dapat diterapkan (JAR, WAR, EAR) menggunakan plugin bawaan Gradle. Kamu berlatih Groovy & Gradle: JVM Automation and Build Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Groovy & Gradle: JVM Automation and Build Engineering?

Tidak diperlukan pengalaman sebelumnya. Groovy & Gradle: JVM Automation and Build Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Mengemas JAR, WAR, EAR” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Groovy & Gradle: JVM Automation and Build Engineering ini?

Ya. Setiap pelajaran Groovy & Gradle: JVM Automation and Build Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Groovy & Gradle: JVM Automation and Build Engineering