Gradle auf Ubuntu 24.04 installieren & Java-App starten

Unter Ubuntu 24.04 ist Gradle in den offiziellen APT-Paketquellen enthalten, auch wenn diese Version möglicherweise nicht die aktuellste ist. Die folgenden Schritte zeigen, wie du Gradle und alle erforderlichen Abhängigkeiten über den APT-Paketmanager auf deinem Server installierst.

Schritt 1: Paketdatenbank aktualisieren

Aktualisiere zunächst die lokale Paketliste deines Systems.

$ sudo apt update

Schritt 2: Gradle installieren

Installiere das Gradle-Paket mit APT.

$ sudo apt install gradle -y

Schritt 3: Installierte Version überprüfen

Prüfe, welche Version von Gradle installiert wurde.

$ gradle --version

Beispielausgabe:

openjdk version "21.0.5" 2024-10-15
OpenJDK Runtime Environment (build 21.0.5+11-Ubuntu-1ubuntu124.04)
OpenJDK 64-Bit Server VM (build 21.0.5+11-Ubuntu-1ubuntu124.04, mixed mode, sharing)
------------------------------------------------------------
Gradle 4.4.1
------------------------------------------------------------
Build time:   2012-12-21 00:00:00 UTC
Revision:     none
Groovy:       2.4.21
Ant:          Apache Ant(TM) version 1.10.14 compiled on September 25 2023
JVM:          21.0.5 (Ubuntu 21.0.5+11-Ubuntu-1ubuntu124.04)
OS:           Linux 6.8.0-48-generic amd64

Gradle über Snap unter Ubuntu 24.04 installieren

Gradle ist auch über den Snap Store verfügbar. Dieser liefert in der Regel neuere Versionen und schnellere Updates. Die folgenden Schritte zeigen, wie du Gradle mit Snap installierst.

Schritt 1: Snap-Dienst installieren

Falls Snap noch nicht installiert ist, kannst du den Dienst mit APT einrichten.

$ sudo apt install snapd -y

Schritt 2: Nach Gradle im Snap Store suchen

Führe eine Suche im Snap Store durch, um verfügbare Gradle-Versionen zu finden.

$ sudo snap search gradle

Beispielausgabe:

Name           Version   Publisher      Notes    Summary
gradle         7.2       snapcrafters✪  classic  An open-source build automation tool
gum            0.13.0    aalmiray       classic  Gum is a Gradle/Maven/Ant/Bach/JBang wrapper written in Go
jreleaser      1.0.0-M1  aalmiray       -        Release Java projects quickly and easily with JReleaser
om26er-gradle  4.7       om26er         -        Accelerate developer productivity
jrel-test      1.0.0-M9  aalmiray       -        Release projects quickly and easily with JReleaser

Laut dieser Ausgabe ist Version 7.2 die aktuell verfügbare Gradle-Version im Snap Store.

Schritt 3: Gradle über Snap installieren

Verwende folgenden Befehl, um Gradle mit klassischer Berechtigung zu installieren.

$ sudo snap install gradle --classic

Schritt 4: Gradle-Installation überprüfen

Führe den folgenden Befehl aus, um sicherzustellen, dass Gradle erfolgreich installiert wurde.

$ sudo snap run gradle --version

Beispielausgabe:

Welcome to Gradle 7.2!
Here are the highlights of this release:
 - Toolchain support for Scala
 - More cache hits when Java source files have platform-specific line endings
 - More resilient remote HTTP build cache behavior
For more details see https://docs.gradle.org/7.2/release-notes.html
------------------------------------------------------------
Gradle 7.2
------------------------------------------------------------

Einfaches Java-Programm mit Gradle erstellen

Die folgenden Schritte zeigen dir, wie du mit Gradle ein simples Java-Programm erstellst und es auf deinem Ubuntu-Server ausführst.

Schritt 1: Neues Projektverzeichnis anlegen

Erstelle ein neues Verzeichnis mit dem Namen sample_project, das als Arbeitsverzeichnis für dein Gradle-Projekt dient.

$ mkdir sample_project

Schritt 2: In das Projektverzeichnis wechseln

Wechsle in das neu erstellte Verzeichnis.

$ cd sample_project

Schritt 3: Gradle-Projekt initialisieren

Initialisiere das Gradle-Projekt mit dem Typ "Java-Anwendung".

$ gradle init --type java-application

Erwartete Ausgabe:

.........  
BUILD SUCCESSFUL in 6s  
2 actionable tasks: 2 executed  
Press Enter to use the default Java version in your project.  

Starting a Gradle Daemon (subsequent builds will be faster)  

Enter target Java version (min: 7, default: 21):  
Verify your project name and press Enter.  

Project name (default: sample_project):  
Enter 1 to set up a single application project.  

Select application structure:  
  1: Single application project  
  2: Application and library project  
Enter selection (default: Single application project) [1..2]  
Select your desired build language. For example, enter 1 to select Kotlin as the build script language.  

Select build script DSL:  
  1: Kotlin  
  2: Groovy  
Enter selection (default: Kotlin) [1..2]  
Select the target test framework. For example, enter 1 to select JUnit 4.  

Select test framework:  
  1: JUnit 4  
  2: TestNG  
  3: Spock  
  4: JUnit Jupiter  
Enter selection (default: JUnit Jupiter) [1..4]  
Press yes to use new APIs with Gradle and initialize your project.  

Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no]  

Schritt 4: Java-Quelldatei hinzufügen

Lege die Verzeichnisstruktur für deine Java-Quelldateien an.

$ mkdir -p src/main/java

Erstelle anschließend die Datei App.java mit einem Texteditor wie nano.

$ nano src/main/java/App.java

Füge folgenden Java-Code in die Datei ein:

public class App {
    public static void main(String[] args) {
        System.out.println("Greetings!");
    }
}

Dieses Programm gibt beim Ausführen die Nachricht Greetings! aus.

Schritt 5: build.gradle bearbeiten

Öffne die Datei build.gradle und füge die Konfiguration für das Java-Plugin und den Einstiegspunkt hinzu.

$ nano build.gradle

Füge folgenden Inhalt ein:

plugins {
    id 'application'
}

application {
    // Define the main class
    mainClass = 'App'
}

jar {
    manifest {
        attributes(
            'Main-Class': 'App'
        )
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // Add dependencies here if needed
}

Schritt 6: Anwendung kompilieren

Kompiliere die Java-Datei und erzeuge eine .jar-Datei mit folgendem Befehl:

$ gradle build

Beispielausgabe:

Calculating task graph as no cached configuration is available for tasks: build

BUILD SUCCESSFUL in 1m 12s  
12 actionable tasks: 12 executed  
Configuration cache entry stored.

Schritt 7: Java-Programm mit Gradle starten

Starte die Anwendung direkt über Gradle:

$ gradle run

Beispielausgabe:

> Task :run  
Greetings!  

> Task :app:run  
Hello World!  

BUILD SUCCESSFUL in 1s  
4 actionable tasks: 2 executed, 2 up-to-date

Schritt 8: .jar-Datei manuell starten

Führe die generierte .jar-Datei manuell mit Java aus:

$ java -jar build/libs/sample_project.jar App

Erwartete Ausgabe:

Greetings!

Webserver-Abhängigkeiten in Gradle einbinden

Mit Gradle kannst du externe Bibliotheken integrieren, um die Funktionen deiner Anwendung zu erweitern. Die folgenden Schritte zeigen dir, wie du Spark Java hinzufügst, um einen einfachen HTTP-Server direkt in deiner Java-Anwendung bereitzustellen.

Schritt 1: build.gradle für Spark Java bearbeiten

Öffne die Datei build.gradle, um die Abhängigkeiten zu ergänzen.

$ nano build.gradle

Füge im Abschnitt dependencies Spark Java hinzu:

dependencies {
    // Add Spark Java for lightweight HTTP server
    implementation 'com.sparkjava:spark-core:2.9.4'
}

Der vollständige Abhängigkeitsblock könnte so aussehen:

dependencies {
    // Add dependencies here if needed
    // Add Spark Java for lightweight HTTP server
    implementation 'com.sparkjava:spark-core:2.9.4'
}

Schritt 2: App.java durch neue Version ersetzen

Sichere zunächst die vorhandene Datei App.java:

$ mv src/main/java/App.java src/main/java/App.ORIG

Erstelle die Datei App.java neu mit Logik für den Webserver:

$ nano src/main/java/App.java

Füge den folgenden Java-Code ein, um einen HTTP-Server über Spark zu starten:

import static spark.Spark.*;

public class App {
    public static void main(String[] args) {
        port(8080); // Port festlegen

        // Route für die Startseite definieren
        get("/", (req, res) -> {
            res.type("text/html");
            return "
Greetings!
"; }); System.out.println("Server läuft unter http://localhost:8080/"); } }

Greetings!

"; }); System.out.println("Server läuft unter http://localhost:8080/"); } }

Diese Version der App startet einen HTTP-Server auf Port 8080 und liefert einen HTML-Gruß.

Schritt 3: Firewall für Port 8080 konfigurieren

Erlaube eingehende Verbindungen über TCP-Port 8080:

$ sudo ufw allow 8080

Lade UFW neu, um die Änderungen anzuwenden:

$ sudo ufw reload

Schritt 4: Webanwendung starten

Führe die Anwendung mit Gradle aus:

$ gradle run

Beispielausgabe:

> Task :run  
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".  
SLF4J: Defaulting to no-operation (NOP) logger implementation  
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.  
Server läuft unter http://localhost:8080/  
<====---------> 37% EXECUTING [49s] > :run

Öffne einen Browser und rufe die IP deines Servers mit Port 8080 auf, um die Anwendung zu testen.

Gradle unter Ubuntu 24.04 deinstallieren

Wenn du Gradle wieder entfernen möchtest, folge den Anweisungen je nach verwendeter Installationsmethode.

Manuelle Installation entfernen

Entferne die Gradle-Binärdateien:

$ sudo rm -rf /opt/gradle/gradle-8.12/bin/gradle

Entferne das Umgebungsvariablen-Skript:

$ sudo rm /etc/profile.d/gradle.sh

APT-Installation entfernen

Wenn du Gradle mit APT installiert hast, nutze diesen Befehl zur Entfernung:

$ sudo apt autoremove gradle -y

Snap-Installation entfernen

Wenn du Gradle über Snap installiert hast, entferne es wie folgt:

$ sudo snap remove gradle

Fazit

Du hast Gradle erfolgreich unter Ubuntu 24.04 installiert, ein Java-Programm erstellt und einen einfachen Webserver integriert. Dank seiner Flexibilität und Skalierbarkeit eignet sich Gradle ideal zum Verwalten von Builds und Abhängigkeiten. Weitere Konfigurationsoptionen findest du in der offiziellen Gradle-Dokumentation.