Gradle über APT unter Ubuntu 24.04 installieren
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/”); } }
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.
