Guide to Spring Reactive Programming using WebFlux
0 likes162 views
Get ready to experience fast and scalable performance in your web applications as we dive into the world of Reactive Programming. Our guide using WebFlux is perfect for both beginners and experts a like.
More Related Content
Similar to Guide to Spring Reactive Programming using WebFlux (20)
More from Inexture Solutions (20)
Recently uploaded (20)
Guide to Spring Reactive Programming using WebFlux
- 1. Guide to Spring Reactive Programming using WebFlux Reactive programming is a programming paradigm that promotes an asynchronous, non-blocking, event driven approach to data processing. Reactive programming involves modelling data and events as observable data streams and implementing data processing routines to react to the changes in those streams. In the reactive style of programming, we make a request for the resource and start performing other things. When the data is available, we get the notification along with the data in the form of call back function. In the callback function, we handle the response as per application /user needs. Features of Reactive Programming • Asynchronous & Non-blocking • Functional style of coding
- 2. • Data flow as event driven stream • Backpressure on data streams When considering whether to use Spring MVC or Spring WebFlux, there are various factors you must consider. Spring MVC: It’s based on a servlet API and follows an imperative programming model. This means you write code in a step-by-step manner, which is generally easier to follow. Spring WebFlux: It offers a reactive programming model. Reactive programming is about handling asynchronous streams of data. This requires a change in thinking and can be more challenging than the traditional imperative model. Spring MVC: If you are familiar with traditional web application development, Spring MVC’s imperative model might seem more straightforward. It’s easier to read, write, and understand for developers accustomed to this approach. Spring WebFlux: Writing reactive code can initially seem complex because of the shift in mindset. However, for some use cases, like streaming data, it can simplify your code. Spring MVC: Debugging is typically more straightforward with an imperative model because the call stacks are more predictable and easier to trace.
- 3. Spring WebFlux: Debugging reactive streams can be tricky, especially for developers new to the reactive paradigm. However, tools and practices are evolving to better support this. Spring MVC: Works naturally with blocking resources like traditional RDBMS using JDBC or JPA (Java Persistence API). Spring WebFlux: If you have blocking dependencies like traditional databases, you might not get the full benefits of the reactive model. However, reactive databases like MongoDB Reactive, Cassandra Reactive, etc., can be integrated natively with WebFlux. Spring MVC: Uses a thread-per-request model. For a high number of simultaneous connections, this can lead to a large number of threads, which may not be efficient. Spring WebFlux: Uses an event-loop concurrency model, which can handle a vast number of simultaneous connections with a smaller number of threads. It’s designed for high concurrency. Spring MVC: Typically runs on servlet containers like Tomcat, Jetty, etc. Spring WebFlux: Runs on reactive runtimes like Netty. This provides non-blocking and highly scalable operations, suitable for high-performance systems. Spring MVC: Typically uses annotated controllers. Spring WebFlux: In addition to annotated controllers, WebFlux supports functional endpoints which allow for programmatic route definitions. Spring WebFlux: As we know, Spring provides Web MVC framework to handle the HTTP requests, but it is Blocking & Non-Reactive in nature, so to support reactive programming Spring provides one more web framework in Spring 5 (includes in Spring Boot 2.0) called WebFlux.
- 4. It is a reactive-stack web framework that is fully non-blocking, supports reactive streams back pressure. It uses project Reactor as a reactive library. The Reactor is a Reactive Streams Library and therefore, all of its operators support non-blocking back pressure. It uses two publishers: • Mono • Flux MONO: A mono is a specialized Publisher that emits at most one item and then optionally terminates with an onComplete signal or an onError signal. In short, it returns 0 or 1 element. • Mono is another implementation of Publisher. • It emits at most one item and then (optionally) terminates with an onComplete signal or an onError signal. • Like Flux, Mono is also asynchronous in nature. Mono noData = Mono.empty(); Mono data = Mono.just(“rishi”); FLUX: A flux is a standard Publisher representing an asynchronous sequence of 0 to N emitted items, optionally terminated by either a completion signal or an error. These three types of signals translate to calls to a downstream subscriber’s onNext, onComplete, or onError methods. • Flux is an implementation of Publisher. • It will emit 0 to N elements and/or a complete or an error call. • Stream pipeline is synchronous whereas Flux pipeline is completely asynchronous. It will emit values only when there is a downstream subscriber. To subscribe, we need to call the subscribe method on Flux. There are different variants of the subscribe method available, which we need to use as per the need: Flux flux1 = Flux.just(“foo”, “bar”, “foobar”);
- 5. Flux flux2 = Flux.fromIterable(Arrays.asList(“A”, “B”, “C”)); Flux flux3 = Flux.range(5, 3); // subscribe flux.subscribe(); Frequently used operations on Mono/Flux • just(-): Create a new Mono that emits the specified item, which is captured at instantiation time. • fromArray(-): Create a Flux that emits the items contained in the provided array. • fromIterable(-): Create a Flux that emits the items contained in the provided iterable. The Iterable.iterator() method will be invoked at least once and at most twice for each subscriber. • fromStream(-): Create a Flux that emits the items contained in a Stream created by the provided Supplier for each subscription. The Stream is closed automatically by the operator on cancellation, error, or completion. • empty(): Create a Flux that completes without emitting any item. • doOnNext(-): Add behaviour (side-effect) triggered when the Flux emits an item. • doOnComplete(-): Add behaviour (side-effect) triggered when the Flux completes successfully. • doOnError(-): Add behaviour (side-effect) triggered when the Flux completes with an error. • map(-): Transform the items emitted by this Flux by applying a synchronous function to each item. • flatMap(-): Transform the item emitted by this Mono asynchronously, returning the value emitted by another Mono (possibly changing the value type). • subscribe(-, -, -): Subscribe a Consumer to this Flux that will consume all the elements in the sequence. It will request an unbounded demand. • log(): Observe all Reactive Streams signals and trace them using Logger support. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead.
- 6. • delayElements(-): Delay each of this Flux elements (Subscriber.onNext signals) by a given Duration. Signals are delayed and continue the parallel default Scheduler, but empty sequences or immediate error signals are not delayed. • block(): Subscribe to this Mono and block indefinitely until a next signal is received. Returns that value, or null if the Mono completes empty. In case the Mono errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception) Working with Spring Web Flux – Understanding the Reactive nature Requirement: Send Promos to all the customers of an e-Commerce website Step-1: Create a Spring Boot project using Maven (Choose Spring Boot version 2.0 or later) Step-2: Add the below spring-boot-starter-webflux dependency in pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> This dependency includes the below dependencies • spring-webflux framework • reactor-core that we need for reactive streams reactor-netty (the default server that supports reactive streams). Any other servlet 3.1+ containers like Tomcat, Jetty or non-servlet containers like Undertow can be used as well Version will be picked from spring-boot-starter-parent dependency version Step-3: Create a Customer DTO class with the fields Id, Name & Email Id
- 7. Step-4: Create a Customer Repo with 2 functions loadCustomers(), loadCustomerStream() as in the below snapshot.
- 8. Step-5: Create a Customer Service with 2 functions, one is to send promos to list of customers, another is to send promos to customer stream
- 9. Step-6: Create a Customer REST Controller with 2 end points as in the below screenshot Summary: Spring introduced a Multi-Event Loop model to enable a reactive stack known as WebFlux. It is a fully non-blocking and annotation-based web framework built on Project Reactor which allows building reactive web applications on the HTTP layer. It provides support for popular inbuilt severs like Netty, Undertow, and Servlet 3.1 containers. WebFlux is also relevant for applications that need scalability or to stream request data in real time. While implementing a micro-service in WebFlux we must consider that the entire flow uses reactive and asynchronous programming and none of the operations are blocking in nature. Originally published by: Guide to Spring Reactive Programming using WebFlux