Install Gradle via APT on Ubuntu 24.04
Ubuntu 24.04 provides Gradle through its default APT repositories, although this version may not be the most recent. The instructions below explain how to use APT to install Gradle and its dependencies on your server.
Step 1: Refresh the Package Database
Begin by updating your system’s package index.
$ sudo apt update
Step 2: Install Gradle
Use APT to install the Gradle package.
$ sudo apt install gradle -y
Step 3: Confirm the Installed Version
Verify which version of Gradle was installed.
$ gradle --version
Sample Output:
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
Install Gradle via Snap on Ubuntu 24.04
Gradle is also distributed through the Snap Store, which may offer newer versions with faster update cycles. Follow the steps below to install Gradle using Snap on your system.
Step 1: Install the Snap Daemon
If Snap is not already installed, use APT to install the daemon.
$ sudo apt install snapd -y
Step 2: Search for Gradle in the Snap Store
Query the Snap Store to see which Gradle versions are currently available.
$ sudo snap search gradle
Expected Output:
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
From the above results, version 7.2 is the available Gradle release in the Snap Store.
Step 3: Install Gradle via Snap
Run the following command to install Gradle with classic confinement.
$ sudo snap install gradle --classic
Step 4: Verify the Gradle Installation
After installation, check the Gradle version to confirm it’s working as expected.
$ sudo snap run gradle --version
Sample Output:
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 ------------------------------------------------------------
Create a Simple Java App with Gradle
Follow the instructions below to build a basic Java application using Gradle and execute it on your Ubuntu server.
Step 1: Make a New Project Directory
Create a directory named sample_project to serve as your Gradle workspace.
$ mkdir sample_project
Step 2: Change to the Project Directory
Navigate into the newly created directory.
$ cd sample_project
Step 3: Initialize a Gradle Java Application
Initialize a Java-based Gradle project with the default application structure.
$ gradle init --type java-application
Expected output:
......... 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]
Step 4: Add Your Application Source File
Create the source folder structure required to store your Java class.
$ mkdir -p src/main/java
Now create a Java file named App.java using a text editor like nano.
$ nano src/main/java/App.java
Insert the following Java code into the file:
public class App {
public static void main(String[] args) {
System.out.println("Greetings!");
}
}
This program will print Greetings! when run.
Step 5: Edit build.gradle File
Open the build.gradle file and define the necessary plugin and application entry point.
$ nano build.gradle
Insert the following configuration:
plugins {
id 'application'
}
application {
// Define the main class
mainClass = 'App'
}
jar {
manifest {
attributes(
'Main-Class': 'App'
)
}
}
repositories {
mavenCentral()
}
dependencies {
// Add dependencies here if needed
}
Step 6: Build the Application
Compile the Java code and package it into a .jar file using the following command:
$ gradle build
Example output:
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.
Step 7: Run the Java App with Gradle
Execute the application using Gradle’s run task.
$ gradle run
Example output:
> Task :run Greetings! > Task :app:run Hello World! BUILD SUCCESSFUL in 1s 4 actionable tasks: 2 executed, 2 up-to-date
Step 8: Run the JAR File Manually
Use Java to manually execute the packaged application JAR.
$ java -jar build/libs/sample_project.jar App
Expected output:
Greetings!
Add Web Server Dependencies in Gradle
Gradle allows you to incorporate libraries and tools to extend your application’s capabilities. The following steps demonstrate how to add the Spark Java framework to create lightweight HTTP server functionality directly in your Java application.
Step 1: Edit build.gradle to Add Spark Java
Begin by opening the build.gradle file to modify the dependencies.
$ nano build.gradle
Update the dependencies block by adding the Spark Java library:
dependencies {
// Add Spark Java for lightweight HTTP server
implementation 'com.sparkjava:spark-core:2.9.4'
}
After modification, the full dependencies section might look like this:
dependencies {
// Add dependencies here if needed
// Add Spark Java for lightweight HTTP server
implementation 'com.sparkjava:spark-core:2.9.4'
}
Step 2: Replace Your App.java File
Backup the original App.java file first.
$ mv src/main/java/App.java src/main/java/App.ORIG
Recreate the App.java file with updated web server logic:
$ nano src/main/java/App.java
Add the following Spark-based server logic to the file:
import static spark.Spark.*;
public class App {
public static void main(String[] args) {
port(8080); // Set the port number
// Define a route for the root URL
get(“/”, (req, res) -> {
res.type(“text/html”);
return “<h1>Greetings!</h1>”;
});
System.out.println(“Server is running at http://localhost:8080/”);
}
}
This version of your app initializes an HTTP server that returns a custom greeting via port 8080.
Step 3: Configure Firewall for Port 8080
Permit incoming connections on TCP port 8080 through your firewall:
$ sudo ufw allow 8080
Reload UFW to activate the changes:
$ sudo ufw reload
Step 4: Run the Web Application
Execute the application using Gradle:
$ gradle run
Example output:
> 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 is running at http://localhost:8080/ <====---------> 37% EXECUTING [49s] > :run
Open your browser and navigate to your server’s IP address at port 8080 to view the web page output.
Uninstall Gradle on Ubuntu 24.04
If you ever need to remove Gradle, follow the appropriate steps depending on your installation method.
Remove Manual Installation
Delete the Gradle binary files:
$ sudo rm -rf /opt/gradle/gradle-8.12/bin/gradle
Remove the environment variable configuration:
$ sudo rm /etc/profile.d/gradle.sh
Remove Gradle Installed via APT
If you used APT to install Gradle, use this command:
$ sudo apt autoremove gradle -y
Remove Gradle Installed via Snap
If you installed it using Snap, run:
$ sudo snap remove gradle
Conclusion
You have successfully installed Gradle on Ubuntu 24.04, created and deployed a basic Java application, and integrated a lightweight web server. Gradle’s scalability and flexibility make it a powerful tool for managing builds and dependencies across diverse development environments. For additional options and configuration guidance, consult the official Gradle documentation.
