Reactive Programming with Java: Mastering map and flatMap

Reactive programming is becoming popular in Java because it can effectively create highly scalable, non-blocking applications that manage large data streams. The key to this paradigm in Project Reactor (found in Spring WebFlux) is the operators, map, and flatMap. This article clarifies how these operators function, their use cases, and their differences.

What is Reactive Programming?

Reactive programming focuses on handling asynchronous data streams in a non-blocking manner. Instead of waiting for one task to complete before moving to the next, you can:

• React to events as they occur.
• Compose complex operations by chaining smaller tasks.
• Scale applications efficiently by freeing up threads for other tasks.

In Java, Project Reactor provides the Flux and Mono APIs for reactive programming:

• Mono: Represents 0 or 1 item.
• Flux: Represents 0 to many items.

The Magic of map: Transforming Your Data

The map operator is used to transform the elements of a stream synchronously. Each element emitted by the source is passed to the map function, which applies a transformation and returns the result. You can use map when you want to perform simple transformations on each element in the stream.

Example 1:

Mono<String> nameMono = Mono.just("John")
    .map(name -> name.toUpperCase());

// Output: JOHN
nameMono.subscribe(System.out::println);

Example 2:

Mono<String> greetingMono = Mono.just("John")
    .map(name -> "Hello, " + name + "!");

// Output: Hello, John!
greetingMono.subscribe(System.out::println);

The Power of flatMap: Handling Async Workflows

The flatMap operator is used to transform elements into another reactive type. It flattens nested publishers into a single stream. You can use flatMap when the transformation involves asynchronous operations or returns a Publisher (e.g., Mono or Flux).

Example 1: Chaining Asynchronous Calls

Imagine you have a service that retrieves user details and another that retrieves their orders. Here’s how you can use flatMap to bridge these two asynchronous calls:

Mono<User> userMono = userRepository.findById(1000000L);

Mono<Order> orderMono = userMono.flatMap(user ->
    orderService.getOrderByUserId(user.getId())
);

orderMono.subscribe(order -> System.out.println(order.toString()));

If we summarise what is happening in the above code;

1. userRepository.findById returns a Mono<User>.
2. orderService.getOrderByUserId returns a Mono<Order>.
3. flatMap bridges these two asynchronous calls.

Example 2: Dealing with Multiple Results

If a user can have multiple orders and orderService.getOrdersByUserId returns a Flux<Order>, you would use flatMapMany.

Mono<User> userMono = userRepository.findById(1000000L);

Flux<Order> ordersFlux = userMono.flatMapMany(user ->
    orderService.getOrdersByUserId(user.getId())
);

ordersFlux.subscribe(order -> System.out.println(order.toString()));

A Real-World Example: Combining map and flatmap

Let’s say we are building a system to manage user accounts. We want to fetch a user’s details, calculate their account balance, and update their profile. The implementation below demonstrates how to achieve this:

Mono<User> updatedUserMono = userService.getUser(1000000L)
    .flatMap(user -> accountService.getAccountBalance(user.getId())
        .map(balance -> {
            user.setBalance(balance);
            return user;
        })
    )
    .flatMap(user -> userRepository.save(user));

updatedUserMono.subscribe(updatedUser ->
    System.out.println("Updated user: " + updatedUser)
);

Here is the breakdown of the above code;

• flatMap: fetches account balance asynchronously
• map: updates the user’s balance synchronously
• flatMap: saves the updated user asynchronously

Tips for Using map and flatMap

• Start with the use case: If the transformation is simple and synchronous, use map. If it involves another reactive operation, use flatMap.
• Avoid nesting: Chaining is preferred over nesting for better readability.
• Combine with other operators: Use filter, doOnNext, or zip alongside map and flatMap to build complex workflows.
• Error Handling: Use error handling operators such as onErrorReturn, onErrorResume, or doOnError to manage exceptions gracefully.

Conclusion

Mastering map and flatMap is crucial for reactive programming in Java, as they enable the composition of complex asynchronous workflows, enhancing application responsiveness and scalability.

When to use map vs flatmap

• Use map for synchronous transformations.
• Use flatMap when dealing with asynchronous operations or for transforming into another reactive type.