Groovy & Gradle: JVM Automation and Build Engineering · Aula

Empacotando JARs, WARs e EARs

Crie vários tipos de artefatos implantáveis (JAR, WAR, EAR) usando os plugins integrados do Gradle.

Aula 1 de 412 etapas

Empacotando JARs, WARs e EARs é uma aula grátis de Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Groovy & Gradle: JVM Automation and Build Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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.

Responda na aula interativa

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.

Grátis para começar

Aprenda Groovy com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 12
Aulas: 48

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Empacotando JARs, WARs e EARs” é grátis?

Sim — o texto completo de “Empacotando JARs, WARs e EARs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Groovy & Gradle: JVM Automation and Build Engineering, atualize para CoddyKit PRO. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.

O que vou aprender em “Empacotando JARs, WARs e EARs”?

Crie vários tipos de artefatos implantáveis (JAR, WAR, EAR) usando os plugins integrados do Gradle. Você pratica Groovy & Gradle: JVM Automation and Build Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Groovy & Gradle: JVM Automation and Build Engineering?

Nenhuma experiência prévia é necessária. Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Empacotando JARs, WARs e EARs”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Groovy & Gradle: JVM Automation and Build Engineering?

Sim. Cada aula de Groovy & Gradle: JVM Automation and Build Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Empacotando JARs, WARs e EARs
Publicando em repositórios
Integração com CI/CD
Versionamento e Automatização de Versões

← Voltar para Groovy & Gradle: JVM Automation and Build Engineering