Mono in Spring Boot Explained with Simple Examples

🟢 Imagine this scenario:
Normally, in Spring Boot (MVC), when you write:

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

👉 Here, the method returns a String directly.

The request → executes the method → response is returned immediately.

🟡 Now, what if the response will come later?

Sometimes data doesn’t come instantly (e.g., fetching from DB, calling another API, adding a delay).
Instead of blocking the thread, we want to return a “promise” that will complete later.

That’s where Mono comes in.
Think of Mono as a box that will contain ONE value in the future.

🔹 Example 1: Basic Mono

@GetMapping("/hello")
public Mono<String> sayHello() {
    return Mono.just("Hello Reactive World!");
}

👉 Here:

Mono.just("Hello Reactive World!") means:
"I promise I will give you this string — just not necessarily right now."
When the browser calls /hello, Spring WebFlux unwraps the Mono and sends the string.

🔹 Example 2: Mono with Delay

@GetMapping("/delayed")
public Mono<String> delayedHello() {
    return Mono.just("Hello after delay!")
               .delayElement(Duration.ofSeconds(2)); // respond after 2 seconds
}

👉 Here:

The response comes after 2 seconds, but the server doesn’t block the thread during the wait.
That means the server can serve other requests meanwhile.
🔹 Example 3: Mono with an Object

record User(String id, String name) {}
@GetMapping("/user")
public Mono<User> getUser() {
    User user = new User("101", "Alice");
    return Mono.just(user);
}

}
👉 Browser Response:

{
  "id": "101",
  "name": "Alice"
}

}
🟢 Very Simple Analogy

Think of Mono as:

A parcel delivery service 📦
You place an order → you get a tracking ID immediately (Mono).
The actual parcel (data) may come later.
When it arrives, you open it and see the item.
So, Mono = “a container for ONE thing that comes now or later.”

✅ Use Mono when:

Your API returns a single item asynchronously.
You want non-blocking performance in Spring WebFlux.