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

It depends on whom you ask that question. "Reactive" is a generic concept describing something as being triggered by a previous action. 

You could argue that programming techniques that follow a non-blocking approach are *reactive programming* styles because you normally use a callback function that reacts to the result. In that broad scope of the ‘reactive’ word, using a `CompletableFuture`, or any other tool based on _promises_, with callbacks would be considered _reactive programming_. However, people normally refer to these libraries and APIs as _asynchronous_ programming.

It’s more common to talk about reactive programming when our code uses one of the existing frameworks that follow the [Reactive Streams spec](https://github.com/reactive-streams/reactive-streams-jvm/blob/master/README.md). Some popular reactive frameworks are [ReactiveX](http://reactivex.io/) (RxJS, RxJava, etc.), [Akka](https://akka.io/), and [Project Reactor](https://projectreactor.io/) (the one used by WebFlux). Java 9 also introduced the Reactive Streams specification with [the Flow API](https://community.oracle.com/docs/DOC-1006738) so the implementers can choose the Java API standards for their libraries. However, that hasn't worked so far, and most of the reactive libraries still use their custom classes. In any case, all these frameworks implement (with some slight differences in naming) patterns like *Observables*, *Publishers*, and *Subscribers*.

Additionally, these reactive frameworks adopt the **backpressure** concept. The main idea of backpressure is that the subscriber has control of the stream, so the consumer can _signal the publisher to stop producing data_ instead of having to accumulate it in buffers. 

> Project Reactor implements backpressure, as we’ll see and demonstrate later in this course.

Learn about the similarities and differences between non-blocking approaches and reactive approaches.

Reactive Web

Full Reactive Stack Backend

Connecting Angular With the WebFlux Backend

Conclusion

Appendix

Is Non-Blocking the Same as Reactive?