# How to build and package a Java application?

## 📌 **Why Do I Need to Build My Java Application?**

Discloud **does not compile Java projects** automatically. 

You must:\
✔ **Compile your code** into `.class` files.\
✔ **Package everything into a single `.jar` file** (including dependencies).\
✔ **Ensure the `META-INF/MANIFEST.MF` file** correctly defines the **Main-Class**.

***

## 🔧 **Choosing a Build Tool**

<table><thead><tr><th width="112">Build Tool</th><th width="367">Best For</th><th>Required Files</th></tr></thead><tbody><tr><td><strong>Maven</strong></td><td>Large projects, dependency-heavy apps</td><td><code>pom.xml</code></td></tr><tr><td><strong>Gradle</strong></td><td>Modern projects with flexible build scripts</td><td><code>build.gradle</code> or <code>build.gradle.kts</code></td></tr></tbody></table>

***

## 📦 **Building Your Java Application**

{% tabs %}
{% tab title="Maven" %}
[Apache Maven](https://maven.apache.org/guides/index.html) is a widely used build automation tool that manages project builds, dependencies, and documentation using a Project Object Model (POM).​

{% stepper %}
{% step %}
Add the Maven Compiler Plugi&#x6E;**.**

Ensure your `pom.xml` includes the **Maven Compiler Plugin** to specify the Java version for compilation. This prevents compatibility issues when running the project.

{% code title="pom.xml" %}

```xml
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.9.9</version>
  <configuration>
    <source>17</source>
    <target>17</target>
  </configuration>
</plugin>
```

{% endcode %}

{% hint style="info" %}

* Set `<source>` and `<target>` to the **Java version** required for your project.
  {% endhint %}
  {% endstep %}

{% step %}
Specify the Main Clas&#x73;**.**

To make your application executable, you need to specify the entry point (`main` method). This is done using the **Maven Shade Plugin**, which also ensures that all dependencies are bundled inside a **single JAR file**.

{% code title="pom.xml" %}

```xml
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      <version>3.2.4</version>
      <executions>
        <execution>
          <phase>package</phase>
          <goals>
            <goal>shade</goal>
          </goals>
          <configuration>
            <transformers>
              <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                <!-- NOTE: Replace this with the correct path to your project's main class -->
                <mainClass>com.project.example.Main</mainClass>
              </transformer>
            </transformers>
          </configuration>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>
```

{% endcode %}

{% hint style="info" %}

* Replace `com.project.example.Main` with the actual **fully qualified name** of your `Main` class.
* Ensure the `Main` class contains a valid `public static void main(String[] args)` method.
  {% endhint %}
  {% endstep %}

{% step %}
Build the Projec&#x74;**.**

Run the following command to **clean** old builds and generate the new JAR files:

```bash
mvn clean package
```

After running `mvn package`, Maven will create **two** different JAR files inside the `target/` directory:

{% stepper %}
{% step %}
Standard JAR (Original Project JAR).

📌 **Filename:** `original-<artifactId>-<version>.jar`\
📌 **Example:** `original-com.maven.discordbot-0.0.1-SNAPSHOT.jar`\
📌 **Contents:**

* Only **your project's compiled code**.
* **Does NOT include dependencies**.

{% hint style="danger" %}
**Do NOT use this file for execution** unless dependencies are handled separately.
{% endhint %}
{% endstep %}

{% step %}
Fat JAR (Shaded JAR with Dependencies).

📌 **Filename:** `<artifactId>-<version>.jar`\
📌 **Example:** `com.maven.discordbot-0.0.1-SNAPSHOT.jar`\
📌 **Contents:**

* Your **compiled application code**.
* **All dependencies included** (JDA, Apache Commons, etc.).
* **Manifest file (`MANIFEST.MF`) with the `Main-Class` entry**.

{% hint style="success" %}
**Use this file for execution and deployment.**
{% endhint %}
{% endstep %}
{% endstepper %}
{% endstep %}
{% endstepper %}
{% endtab %}

{% tab title="Gradle" %}
[Gradle](https://gradle.org/) is a flexible build automation tool that uses a Groovy or Kotlin-based DSL to define the build process.​

{% stepper %}
{% step %}
Apply the Java Plugin.

Ensure your `build.gradle` (Groovy) or `build.gradle.kts` (Kotlin) applies the **Java plugin**:

{% tabs %}
{% tab title="Groovy" %}
{% code title="build.gradle" %}

```groovy
plugins {
    id 'java'
    id 'com.gradleup.shadow' version '8.3.6' // Shadow Plugin for Fat JAR
}
```

{% endcode %}
{% endtab %}

{% tab title="Kotlin" %}
{% code title="build.gradle.kts" %}

```kotlin
plugins {
    java
    id("com.gradleup.shadow") version "8.3.6"
}
```

{% endcode %}
{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}
Specify the Main Class.

To make the application executable, define the **entry point (`main` method)** inside the **JAR manifest**.

{% tabs %}
{% tab title="Groovy" %}
{% code title="build.gradle" %}

```groovy
shadowJar {
    archiveClassifier.set('all')
    manifest {
        attributes(
            'Main-Class': 'com.project.Main' // Replace with your actual main class
        )
    }
}

tasks.build.dependsOn shadowJar // Ensure shadowJar runs when building
```

{% endcode %}
{% endtab %}

{% tab title="Kotlin" %}
{% code title="build.gradle.kts" %}

```kotlin
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

tasks.withType<ShadowJar> {
    archiveClassifier.set("all")
    manifest {
        attributes(mapOf("Main-Class" to "com.project.Main")) // Replace with your actual main class
    }
}

tasks.named("build") {
    dependsOn("shadowJar")
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

{% hint style="info" %}

* Replace `"com.project.Main"` with the **fully qualified name** of your `Main` class.
  {% endhint %}
  {% endstep %}

{% step %}
Build the Project.

To clean old builds and generate new JAR files, run:

```groovy
gradle clean build
```

{% stepper %}
{% step %}
Standard JAR (Regular Project JAR).

📌 **Filename:** `<project-name>.jar`\
📌 Exampl&#x65;**:**  `discordbot.jar`\
📌 **Contents:**

* Only **your project's compiled code**.
* **Does NOT include dependencies**.

{% hint style="danger" %}
**Do NOT use this file for execution** unless dependencies are handled separately.
{% endhint %}
{% endstep %}

{% step %}
Fat JAR (Uber JAR with Dependencies).

📌 **Filename:** `<project-name>-all.jar`\
📌 Exampl&#x65;**:**  `discordbot-all.jar`\
📌 **Contents:**

* Your **compiled application code**.
* **All dependencies included** (JDA, Apache Commons, etc.).
* **Manifest file (`MANIFEST.MF`) with the `Main-Class` entry**.

{% hint style="success" %}
**Use this file for execution and deployment.**
{% endhint %}
{% endstep %}
{% endstepper %}
{% endstep %}
{% endstepper %}
{% endtab %}
{% endtabs %}

{% hint style="info" %}

#### **Recommendation**

Rename your JAR file to a simple name like `app.jar` to avoid issues with special characters.​
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.discloud.com/en/faq/general-questions/how-to-build-and-package-a-java-application.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.