Spring Boot Gradle Multi-Module Project

🎓 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

Setting up a multi-module project with Spring Boot and Gradle helps you organize your codebase into smaller, manageable modules. In this tutorial, we'll create a multi-module project for a blogging application consisting of core, common, and web modules. Each module will serve a specific purpose in the application.

Project Structure

The project structure will look like this:

blogger
├── build.gradle
├── settings.gradle
├── blogger-core
│   ├── build.gradle
│   └── src/main/java/com/example/core
├── blogger-common
│   ├── build.gradle
│   └── src/main/java/com/example/common
├── blogger-web
│   ├── build.gradle
│   └── src/main/java/com/example/web
└── gradle
    └── wrapper
        ├── gradle-wrapper.jar
        └── gradle-wrapper.properties

Step 1: Create the Parent Project

Create the parent project directory:

mkdir blogger
cd blogger

Create settings.gradle file:

rootProject.name = 'blogger'
include 'blogger-core', 'blogger-common', 'blogger-web'

Create build.gradle file for the parent 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 = '1.0.0'
sourceCompatibility = '17'

allprojects {
    repositories {
        mavenCentral()
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'io.spring.dependency-management'

    dependencies {
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
        testImplementation 'org.mockito:mockito-core:5.1.1'
        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
    }

    test {
        useJUnitPlatform()
    }
}

Step 2: Create a Core Module

Create the core module directory:

mkdir -p blogger-core/src/main/java/com/example/core

Create build.gradle file for the core module:

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

Add a simple service class:

`blogger-core/src/main/java/com/example/core/GreetingService.java`

package com.example.core;

import org.springframework.stereotype.Service;

@Service
public class GreetingService {
    public String greet(String name) {
        return "Hello, " + name;
    }
}

Step 3: Create a Common Module

Create the common module directory:

mkdir -p blogger-common/src/main/java/com/example/common

Create build.gradle file for the common module:

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

Add a utility class:

`blogger-common/src/main/java/com/example/common/StringUtils.java`

package com.example.common;

public class StringUtils {
    public static boolean isNullOrEmpty(String str) {
        return str == null || str.isEmpty();
    }
}

Step 4: Create a Web Module

Create the web module directory:

mkdir -p blogger-web/src/main/java/com/example/web

Create build.gradle file for the web module:

dependencies {
    implementation project(':blogger-core')
    implementation project(':blogger-common')
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

Add a controller class:

`blogger-web/src/main/java/com/example/web/GreetingController.java`

package com.example.web;

import com.example.core.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        return greetingService.greet(name);
    }
}

Step 5: Running the Application

Add the main application class:

`blogger-web/src/main/java/com/example/web/WebApplication.java`

package com.example.web;

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

@SpringBootApplication(scanBasePackages = {"com.example.core", "com.example.common", "com.example.web"})
public class WebApplication {

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

Run the application:

./gradlew :blogger-web:bootRun

Conclusion

In this tutorial, we've set up a multi-module Spring Boot project using Gradle. Each module has a specific responsibility, making the codebase more modular and easier to maintain. You can extend this setup with more modules and functionalities as needed. For more information and best practices, refer to the Spring Boot documentation and Gradle documentation.

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