Spring Boot Gradle Project Example

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Gradle is a powerful build automation tool that is widely used in the Java ecosystem. In this tutorial, we'll create a simple Spring Boot application using Gradle. We will cover the basic setup and structure of a Spring Boot project with Gradle.

Prerequisites

JDK 17 or later
Gradle
Spring Boot (version 3.2+ recommended)
IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project Using Spring Initializr

Use Spring Initializr to generate a new Spring Boot project with the following configuration:

Project: Gradle Project
Language: Java
Spring Boot: 3.2.x
Dependencies: Spring Web

Download the generated project, unzip it, and open it in your IDE.

Project Structure

The basic structure of a Spring Boot project with Gradle looks like this:

my-spring-boot-app/
├── build.gradle
├── settings.gradle
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   └── test/
│       └── java/
│           └── com/example/demo/
│               └── DemoApplicationTests.java
└── gradlew
└── gradlew.bat
└── gradle/
    └── wrapper/
        └── gradle-wrapper.properties

Step 2: Configuring `build.gradle`

Open the build.gradle file and review its content. This file contains the configuration needed to build your project.

plugins {
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

Explanation:

plugins: Defines the Gradle plugins required for the project.
- org.springframework.boot: Spring Boot plugin.
- io.spring.dependency-management: Plugin for managing dependencies.
- java: Java plugin.
group and version: Define the group ID and version of the project.
sourceCompatibility: Sets the Java version compatibility.
repositories: Specifies the repositories for dependencies.
- mavenCentral: Maven Central repository.
dependencies: Lists the project dependencies.
- implementation 'org.springframework.boot:spring-boot-starter-web': Spring Boot Starter for building web applications.
- testImplementation 'org.springframework.boot:spring-boot-starter-test': Spring Boot Starter for testing.
test: Configures the test task to use the JUnit Platform.

Step 3: Create the Application Class

Create a Java class named DemoApplication in the src/main/java/com/example/demo directory.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Explanation:

@SpringBootApplication: Marks this class as the main entry point for the Spring Boot application.
main method: Starts the Spring Boot application.

Step 4: Create a REST Controller

Create a Java class named HelloController in the src/main/java/com/example/demo directory.

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

Explanation:

@RestController: Marks this class as a REST controller.
@GetMapping("/hello"): Maps HTTP GET requests to the /hello endpoint to the sayHello method.
sayHello method: Returns a "Hello, World!" message.

Step 5: Create a Test Class

Create a Java class named DemoApplicationTests in the src/test/java/com/example/demo directory.

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
    }
}

Explanation:

@SpringBootTest: Indicates that this is a Spring Boot test.
contextLoads method: Tests if the Spring application context loads successfully.

Step 6: Running the Application

Using IDE

You can run the application directly from your IDE. Look for a "Run" or "Debug" option for the DemoApplication class.

Using Gradle

Alternatively, you can run the application using the Gradle wrapper. Open a terminal in the project root directory and run the following command:

./gradlew bootRun

Explanation:

./gradlew: The Gradle wrapper script.
bootRun: A task provided by the Spring Boot Gradle plugin to run the application.

Step 7: Verify the Application

Open a web browser or a tool like Postman and navigate to the following URL to verify the application:

Hello Endpoint:
- URL: http://localhost:8080/hello
- Method: GET
- Response: Hello, World!

You should see the "Hello, World!" message returned by the HelloController.

Conclusion

In this tutorial, you have learned how to create a simple Spring Boot application using Gradle. We covered:

Setting up a Spring Boot project using Spring Initializr with Gradle.
Configuring the build.gradle file.
Creating the main application class.
Creating a REST controller.
Creating a test class.
Running the application using an IDE and the Gradle wrapper.
Verifying the application by accessing a REST endpoint.

By following these steps, you can easily set up and manage Spring Boot projects using Gradle.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog