Spring WebFlux & Reactor Core
Build reactive REST APIs using Spring WebFlux, working with `Mono` and `Flux` from Reactor Core.
Spring WebFlux & Reactor Core is a free Spring Boot 4 Complete Guide lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Spring Boot 4 Complete Guide learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Reactive Web with Spring WebFlux
Welcome to Spring WebFlux! This framework is Spring's answer to building reactive, non-blocking web applications.
Unlike traditional Spring MVC which uses a servlet-based, blocking model, WebFlux is designed for concurrency and high throughput with fewer threads.
It's perfect for microservices and applications needing to handle many concurrent connections efficiently.
Diving into Reactor Core
At the heart of Spring WebFlux lies Reactor Core. Reactor is a reactive programming library that implements the Reactive Streams specification.
It provides two key types for handling asynchronous data streams:
Mono: For sequences of 0 or 1 item.Flux: For sequences of 0 to N items.
These types represent publishers that emit data, which subscribers then consume.
`Mono`: Zero or One Element
A Mono is a specialized Publisher that can emit at most one item, or complete without emitting any item, or emit an error.
Think of it as an asynchronous container for a single value. It's ideal for operations that return a single result, like fetching a user by ID or performing a single update.
Your First `Mono`
Let's see Mono in action. We create a Mono and then subscribe() to it. The subscribe() method triggers the data flow.
import reactor.core.publisher.Mono;
public class Main {
public static void main(String[] args) {
Mono<String> greetingMono = Mono.just("Hello, Mono!");
// Subscribe to the Mono to consume the data
greetingMono.subscribe(
data -> System.out.println(data), // onNext consumer
error -> System.err.println("Error: " + error), // onError consumer
() -> System.out.println("Mono completed.") // onComplete callback
);
}
}`Flux`: Zero to Many Elements
A Flux is a Publisher that can emit 0 to N items over time, and then optionally terminate with a completion signal or an error.
It's perfect for handling streams of data, like a list of products, real-time events, or database query results that return multiple rows.
Your First `Flux`
Here's an example of creating a Flux from a list of items. Just like Mono, you need to subscribe() to start the emission of data.
import reactor.core.publisher.Flux;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
Flux<String> fruitFlux = Flux.fromIterable(fruits);
// Subscribe to the Flux to consume the data stream
fruitFlux.subscribe(
data -> System.out.println(data), // onNext consumer for each item
error -> System.err.println("Error: " + error), // onError consumer
() -> System.out.println("Flux completed.") // onComplete callback
);
}
}Building Reactive Endpoints
Spring WebFlux seamlessly integrates with Reactor Core's Mono and Flux. You can define your REST endpoints to return these reactive types.
When a WebFlux controller method returns a Mono or Flux, Spring handles the subscription and streaming of data automatically, allowing for non-blocking I/O.
Endpoint Returning `Mono`
Here's how you'd create a simple WebFlux endpoint that returns a Mono<String>. This endpoint would respond with a single string asynchronously.
Note: This code snippet is part of a Spring Boot application and cannot be run in isolation.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;
@RestController
public class HelloController {
@GetMapping("/hello-mono")
public Mono<String> getHelloMono() {
// Simulate a non-blocking operation that returns a single greeting
return Mono.just("Hello from Mono endpoint!");
}
}Endpoint Returning `Flux`
For endpoints that need to stream multiple items, you can return a Flux<T>. WebFlux will handle sending these items as they become available, often using Server-Sent Events (SSE).
Note: This code snippet is part of a Spring Boot application and cannot be run in isolation.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import java.time.Duration;
@RestController
public class HelloController {
@GetMapping(value = "/hello-flux", produces = "text/event-stream")
public Flux<String> getHelloFlux() {
// Emit 5 items, one every second
return Flux.interval(Duration.ofSeconds(1))
.map(sequence -> "Item " + sequence + " from Flux!")
.take(5);
}
}Check Your Knowledge
Let's test your understanding of Spring WebFlux and Reactor Core.
Recap: WebFlux & Reactor Core
In this lesson, you've learned about the core components of reactive programming with Spring Boot:
- Spring WebFlux: The non-blocking web framework.
- Reactor Core: The underlying library providing reactive types.
Mono: For handling 0 or 1 data item.Flux: For handling 0 to N data items.
You also saw how to define reactive endpoints in WebFlux controllers by returning Mono and Flux.
Frequently asked questions
Is the “Spring WebFlux & Reactor Core” lesson free?
Yes — the full text of “Spring WebFlux & Reactor Core” is free to read here on the web, and the Spring Boot 4 Complete Guide course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Spring Boot 4 Complete Guide course, upgrade to CoddyKit PRO.
What will I learn in “Spring WebFlux & Reactor Core”?
Build reactive REST APIs using Spring WebFlux, working with `Mono` and `Flux` from Reactor Core. You practise Spring Boot 4 Complete Guide with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Spring Boot 4 Complete Guide?
No prior experience is required. Spring Boot 4 Complete Guide on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Spring WebFlux & Reactor Core” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Spring Boot 4 Complete Guide lesson?
Yes. Every Spring Boot 4 Complete Guide lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.