Spring Reactive Stack

Future of communication

With the rapid technological advances in communication technology and the beginning of the 5G era, it’s a matter of time before billions of devices are connected to the internet to perform all sorts of queries to servers.

Spring’s Servlet Stack

The most common use of Spring nowadays is the servlet stack usage. This method assigns a new thread to each new incoming request and follows a thread blocking execution behavior. Those two properties make Servlet Spring a bad candidate for future backend servers that will serve millions of requests in very brief amounts of time. So what’s the solution?

Spring’s Reactive Stack

There is a lot of excellent resources explaining the benefit of the new reactive stack, I will list some at the end. However, I’ll provide the most two important properties of the reactive stack:

• Asynchronous

if the thread reaches a line of code that requires it to wait for a response, the thread doesn’t sit around waiting, it handles other work while the response becomes available.

• Declarative

it’s a programming paradigm that expresses the logic of a computation(What to do) without describing its control flow(How to do).

for example “For each element in this list, apply this logic and collect the result into a list”

How does it work?

Once again, there is a lot of great resources about this that I will share at the end. But, to give you a broad understanding, it uses two main constructs called the Mono and Flux.

• Mono

Emits at most one item via the onNext signal then terminates with an onComplete signal (successful Mono, with or without value), or only emits a single onError signal (failed Mono)

• Flux

Emits 0 to N elements, and then completes (successfully or with an error). Furthermore, it provides two options

1- Streaming, with backpressure control (the client and server can talk about slowing down the data flow if the client is having trouble keeping up with the data flow speed)

2- Non-streaming

Simple Demo

We are going to write a backend server, which populates a single dummy Post entity and saves it into the database. We will offer some endpoints to perform CRUD operations on that entity and add new Posts.

let’s start with the database. we will use MongoDB simply because it’s reactive in nature and integrated well with our Reactive stack.

@Data @AllArgsConstructor @NoArgsConstructor
@Builder @Document
public class Post {
    @Id
    private String id;
    private Date publicationDate;
    private String title;
    private User owner;
}

The Spring Data repository

@Repository
public interface PostRepository extends ReactiveCrudRepository<Post, String> {
}

The Post Service

@Service
@RequiredArgsConstructor
@Slf4j
public class PostService {
    private final PostRepository postRepository;
    // check the code below
}

So, let’s take a look at the reactive methods

// the methods from portRepository provide methods that return Flux and Mono objects
// since it extends the ReactiveCrudRepository interface

public Flux<Post> getAllPosts(){
    return postRepository.findAll();
}
public Mono<Post> getPostById(String id) {
    return postRepository.findById(id);
}
public Mono<Post> addNewPost(Post postFromClient) {
    return postRepository.save(postFromClient);
}

The delete Post method needed a bit more code

public Mono<ResponseEntity<Object>> deletePost(String id) {
    return postRepository.
            findById(id).
            map(Optional::ofNullable). // => get Optional 
            defaultIfEmpty(Optional.empty()). // 
            doOnSuccess(post -> checkAndDeletePost(post, id)).
            thenReturn(ResponseEntity.ok().build());
}
private void checkAndDeletePost(Optional<Post> post, String id) {
    post.ifPresentOrElse(
        p -> postRepository.delete(p).subscribe(),
        () -> log.info(String.format("%s Post doesn't exist", id)));
}

The update Post method

public Mono<ResponseEntity<Object>> updatePost(Post updatedPost){
    return postRepository.
        findById(updatedPost.getId()).
        map(Optional::ofNullable).
        defaultIfEmpty(Optional.empty()).
        doOnSuccess(oldPost ->
                checkAndUpdatePost(oldPost, updatedPost)).
        thenReturn(ResponseEntity.ok().build());
}

private void checkAndUpdatePost(Optional<Post> oldPost, Post updatedPost) {
    oldPost.ifPresentOrElse(
        oldP -> postRepository.save(updatedPost).subscribe(),
        () -> log.info(String.format("%s Post doesn't exist",
                                    updatedPost.getId())));
}

I know I didn’t explain a lot of what’s going on in the code (defaultIfEmpty, doOnSuccess, thenReturn, subscribe). I just wanted to give you a taste of the reactive side of Spring.

Code on GitHub

https://github.com/Jarjanazy/first-timers

Resources to dive deeper

Reactor 3 Reference Guide

Spring WebFlux Tutorial - Spring Boot WebFlux Example - HowToDoInJava

https://www.youtube.com/watch?v=IZ2SoXUiS7M&ab_channel=SpringDeveloper