🍃Taste Of Spring Reactive Stack
Tags: java, programming, tutorial, webdev
Published: 2021-05-27 20:11:23

## 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 ♻️
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? 🧐
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.

## 🛂
```java
@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
```java
@Repository
public interface PostRepository extends ReactiveCrudRepository<Post, String> {
}
```
## 👨🏿‍✈️
The Post Service 
```java
@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
```java
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
```java
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())));
}
```

## Code on [GitHub] (https://github.com/Jarjanazy/first-timers)

## Resources to go deeper
[GOTO 2019 • Reactive Spring • Josh Long] (https://www.youtube.com/watch?v=1F10gr2pbvQ&t=1528s&ab_channel=GOTOConferences)