Java Tutorial: Understanding Mono and Flux 🎯

Welcome to our deep dive into Java's Reactive Programming! Today, we'll learn about two fundamental concepts: Mono and Flux. These are essential components of Project Reactor, a powerful library for building reactive applications.

What is Mono? 💡

Mono<T> represents a sequence containing either a single item of type T or an empty sequence. It's a way to handle a single data item or an error, making it ideal for methods that are expected to return a single item or an exception.

Creating a Mono

You can create a Mono instance in several ways. Here's an example of creating a Mono from a T value:

java

Mono<String> mono = Mono.just("Hello World!");

Using Mono in a Real-World Scenario

Suppose you're developing a simple web application, and you want to read a user's profile from a database. If the user exists, you return their profile; otherwise, you throw an exception. This is perfect for using Mono.

java

Mono<User> getUserProfile(String username) {
    // Database query to fetch user profile
    // Return the User object if found, otherwise throw an exception
}

What is Flux? 📝

Flux<T> represents a sequence of 0 or more items of type T. It's primarily used when you expect to handle multiple items or an empty sequence.

Creating a Flux

Creating a Flux instance is similar to creating a Mono. Here's an example of creating a Flux from an array of String values:

java

Flux<String> flux = Flux.fromArray(new String[]{"One", "Two", "Three"});

Using Flux in a Real-World Scenario

Let's consider a scenario where you're developing a chat application. Each user can send multiple messages. Here, you can use Flux to manage these messages.

java

Flux<Message> getUserMessages(String username) {
    // Database query to fetch messages for the user
    // Return a `Flux` of messages
}

Working with Mono and Flux: Operators and Helper Methods ✅

Both Mono and Flux support a set of operators and helper methods to perform various operations, like mapping, filtering, and combining sequences.

Common Operators and Helper Methods

map: Apply a given function to each item in a sequence
filter: Retain only items that satisfy a given predicate
flatMap: Transform each item into a sequence and concatenate the resulting sequences
switchIfEmpty: If the sequence is empty, use the provided publisher instead

Example Using Operators and Helper Methods

Let's take the example of the chat application and apply some operators to filter or map the messages.

java

Flux<Message> getUserMessages(String username) {
    // Database query to fetch messages for the user
    // Return a `Flux` of messages
}

Flux<Message> filterMessagesByRecipient(Flux<Message> messages, String recipient) {
    return messages.filter(message -> message.getRecipient().equals(recipient));
}

Flux<String> mapMessagesToContent(Flux<Message> messages) {
    return messages.map(Message::getContent);
}

Quiz 💡

Happy learning, and see you in the next lesson! 🚀