Groovy & Gradle: JVM Automation and Build Engineering · Lekcja

Pakowanie JAR, WAR i EAR

Twórz różne typy artefaktów do wdrożenia (JAR, WAR, EAR) za pomocą wbudowanych wtyczek Gradle.

Pakowanie JAR, WAR i EAR to bezpłatna lekcja Groovy & Gradle: JVM Automation and Build Engineering na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Groovy & Gradle: JVM Automation and Build Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Groovy & Gradle: JVM Automation and Build Engineering zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Często zadawane pytania

Czy lekcja „Pakowanie JAR, WAR i EAR” jest bezpłatna?

Tak — pełny tekst „Pakowanie JAR, WAR i EAR” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Groovy & Gradle: JVM Automation and Build Engineering, przejdź na CoddyKit PRO. Kurs Groovy & Gradle: JVM Automation and Build Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Pakowanie JAR, WAR i EAR”?

Twórz różne typy artefaktów do wdrożenia (JAR, WAR, EAR) za pomocą wbudowanych wtyczek Gradle. Ćwiczysz Groovy & Gradle: JVM Automation and Build Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Groovy & Gradle: JVM Automation and Build Engineering?

Nie wymagamy żadnego doświadczenia. Groovy & Gradle: JVM Automation and Build Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Pakowanie JAR, WAR i EAR”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Groovy & Gradle: JVM Automation and Build Engineering?

Tak. Każda lekcja Groovy & Gradle: JVM Automation and Build Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Groovy & Gradle: JVM Automation and Build Engineering