Gain insights into building Reactive Web Applications with Spring Boot 2 and Spring WebFlux, from database integration to front-end. Explore Reactive vs MVC, performance, and deployment with Docker.   


Full Reactive Stack with Spring Boot 2 and Spring WebFlux.png

tarball.tar.gz

initialzr

spring-mongo-only

Lesson-playing-with-reactive-endpoints

angular-app-with spring-mongo

angular-app-with spring-mongo-copy

spring-mongo-only-copy

initialzr-copy

This course is your guide to using Spring Boot 2 and Spring WebFlux to create Reactive Web Applications. 

You will learn how to build a full-reactive system from the database (MongoDB reactive) to the front-end (Angular), using a Reactive programming strategy leveraged by Spring WebFlux, with the simplicity offered by Spring Boot 2. 

Beyond that though, you will be able to compare the Spring WebFlux with the standard MVC approach as well, covering the main aspects such as simplicity, performance, user experience, and more.

The last part of the course ties it all up by teaching you to run the application using Docker compose. By the end of this course, you will have a great new skill for your resume and you’ll be able to build your own projects using the full Reactive stack.

Full Reactive Stack: Spring Boot 2 & Spring WebFlux

# Different test configurations

Interestingly enough, implementing a full reactive web stack introduces some extra delay in the total time required to retrieve a response from the server. This is due to the extra processing needed to make the communication work. Therefore, we can't extract conclusions by looking at the requests one by one.

The reactive web approach shines when we measure the whole performance of the server handling multiple requests at the same time. In this section, we'll go through different test configuration options, and we'll see the results in graphs that compare the WebFlux implementation to the Web MVC one.

The results come from a benchmark test that you can run yourself. In the GitHub backend’s project folder, [spring-boot-reactive-web](https://github.com/mechero/full-reactive-stack/tree/master/spring-boot-reactive-web), you’ll find the `BenchmarkTest` test class. Remove the `@Ignore` annotation and run the tests or just use your IDE to execute it.

# Benchmark details

I used an Intel Core i7 @ 2.5 GHz with one processor and four cores for the test. The backend runs from IntelliJ IDEA (not Docker). I didn’t modify the default configuration for Netty, which in my case is running **eight parallel server threads**.

The benchmark allows you to configure:

- The total number of requests to execute
- The number of requests to run in parallel (parallelism)

Every request performed by the client should take at least one second since the delay per element is 100ms, and we’re asking the server for 10 quotes. The existing code runs 1, 8, 32, 96, and 768 requests four times:

- With parallelism of 32 and invoking the reactive endpoint
- With parallelism of 32 and invoking the blocking endpoint
- With parallelism of 96 and invoking the reactive endpoint
- With parallelism of 96 and invoking the blocking endpoint

To avoid potential differences in the test implementation, both reactive and blocking requests use a `WebClient`, the reactive client that comes with the new Spring WebFlux. I also tried using the RestTemplate for the blocking part with very similar results. The log levels of the application are in the repository, so you can get some valuable information from them when running the benchmark, i.e., threads started, locks acquired and released, etc.


Analyze the performance of the reactive approach (Spring WebFlux) and the blocking approach (Spring MVC).

Reactive Web

Full Reactive Stack Backend

Connecting Angular With the WebFlux Backend

Conclusion

Appendix

WebFlux vs. Blocking (MVC): Performance

Different test configurations