Skip to main content

Reactive Programming in Spring WebFlux Series - IV

· 4 min read

Data Stream Transformation and Operations


Data Stream Transformation​

In reactive programming, transforming and operating on data streams is a core aspect. Using different operators, we can handle data streams flexibly, applying transformations, filtering, aggregating, and more. Below are some common data stream operations and examples.

1. map Operator​

The map operator transforms each element in a data stream. It takes a function as an argument and applies it to each element.

Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5)
.map(n -> n * n);

numbers.subscribe(System.out::println); // Output: 1, 4, 9, 16, 25

2. flatMap Operator​

The flatMap operator maps each element to a new Publisher and merges them into a single Flux. It is often used for asynchronous processing.

Flux<String> ids = Flux.just("1", "2", "3");
Flux<User> users = ids.flatMap(id -> userRepository.findById(id));

users.subscribe(System.out::println);

3. filter Operator​

The filter operator filters data streams, keeping only elements that meet a certain condition.

Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5)
.filter(n -> n % 2 == 0);

numbers.subscribe(System.out::println); // Output: 2, 4

4. reduce Operator​

The reduce operator aggregates all elements in a data stream into a single value. It takes an accumulator function, combining the previous result with the current element.

Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5);
Mono<Integer> sum = numbers.reduce((a, b) -> a + b);

sum.subscribe(System.out::println); // Output: 15

Practical Example: Building a Complex Data Stream Processing Application​

Below is an example showing how to use these operators to build a complex reactive application in Spring WebFlux.

1. Project Setup​

Ensure that the following dependencies are included in your project:

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-core</artifactId>
</dependency>
</dependencies>

2. Data Model​

Define a simple user data model:

public class User {
private String id;
private String name;

// Constructors, Getters and Setters
}

3. Mock Data Source​

Create a mock data source:

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.List;

public class UserRepository {
private static final List<User> users = Arrays.asList(
new User("1", "John Doe"),
new User("2", "Jane Doe"),
new User("3", "Sam Smith")
);

public Mono<User> findById(String id) {
return Mono.justOrEmpty(users.stream()
.filter(user -> user.getId().equals(id))
.findFirst());
}

public Flux<User> findAll() {
return Flux.fromIterable(users);
}
}

4. Handler Functions and Route Configuration​

Set up handler functions and route configuration:

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import reactor.core.publisher.Mono;

@Component
public class UserHandler {
private final UserRepository userRepository;

public UserHandler(UserRepository userRepository) {
this.userRepository = userRepository;
}

public Mono<ServerResponse> getUser(ServerRequest request) {
String userId = request.pathVariable("id");
return userRepository.findById(userId)
.flatMap(user -> ServerResponse.ok().body(Mono.just(user), User.class))
.switchIfEmpty(ServerResponse.notFound().build());
}

public Mono<ServerResponse> getAllUsers(ServerRequest request) {
return ServerResponse.ok().body(userRepository.findAll(), User.class);
}
}

@Configuration
public class RouterConfig {
@Bean
public RouterFunction<ServerResponse> route(UserHandler handler) {
return RouterFunctions.route()
.GET("/user/{id}", handler::getUser)
.GET("/users", handler::getAllUsers)
.build();
}
}

Conclusion​

In this article, we explored how to transform and operate on data streams in Spring WebFlux. Using different operators, we can flexibly handle data streams, building complex reactive applications.