In this article, we will see how to build reactive REST APIs with Spring WebFlux. Before jumping into the reactive APIs, let us see how the systems evolved, what problems we see with the traditional REST implementations, and the demands from modern APIs.
If you look at the expectations from legacy systems to modern systems described below,
The expectations from the modern systems are: the applications should be distributed, Cloud Native, embracing for high availability, and scalability. So the efficient usage of system resources is essential. Before jumping into Why reactive programming to build REST APIs? Let us see how the traditional REST APIs request processing works.
Below are the issues what we have with the traditional REST APIs,
Let us see how we can solve the above issues using reactive programming. Below are the advantages we will get with reactive APIs.
Now, let us see how Reactive Programming works. In the below example, once the application makes a call to get the data from a data source, the thread will be returned immediately, and the data from the data source will come as a data/event stream. Here, the application is a subscriber, and the data source is a publisher. Upon the completion of the data stream, the onComplete
event will be triggered.
Below is another scenario where the publisher will trigger an onError
event if any exception happens.
In some cases, there might not be any items to deliver from the publisher. For example, deleting an item from the database. In that case, the publisher will trigger the onComplete
/onError
event immediately without calling onNext
event, as there is no data to return.
Now, let us see **what is backpressure **and how we can apply backpressure to the reactive streams.For example, we have a client application that is requesting data from another service. The service is able to publish the events at the rate of 1000TPS but the client application is able to process the events at the rate of 200TPS.
In this case, the client application should buffer the rest of the data to process. Over the subsequent calls, the client application may buffer more data and eventually run out of memory. This causes the cascading effect on the other applications which depends on the client application. To avoid this the client application can ask the service to buffer the events at their end and push the events at the rate of the client application. This is called backpressure. The below diagram depicts the same.
#java #tutorial #spring boot #reactive streams #project reactor #spring web flux