Build Reactive RESTFUL APIs using Spring Boot/WebFlux
More
This course is structured to give you both the theoretical and coding aspect of Reactive Programming and Reactive RestFul APIs using Spring WebFlux.
If you are looking forward to learn the below listed things:
What is Reactive Programming ?
Write Reactive Programming code with Spring WebFlux.
Write Reactive Programming code with DB.
Building Reactive RestFul APIs with Spring WebFlux
Then this is the right course for you. This is a pure hands on oriented course where you will be writing lots of code.
By the end of this course you will have the complete understanding of coding and implementing a Reactive API using Spring WebFlux.
Why Reactive Programming ?
This section highlights about the need for reactive programming and explains in detail about the current execution model in spring-mvc.
This sections explains about the drawbacks in spring-mvc.
This section explains about the concurrency model in spring-mvc.
What is Reactive Programming?
This section talks about "What is Reactive Programming ?"
How Reactive programming works in a nutshell using a simple example.
This section will give you all an introduction to Reactive Streams Specification.
This section will give all an introduction to "Reactive Libraries" that are out there.
Getting started with Project Reactor
This section will give you all the fundamentals of Project Reactor and explore the project reactor using some examples.
This section covers the Reactive Types Flux and Mono in detail.
Setting up the Project for this course
In this section we will set up the project for this course using the Spring Intializr website.
Reactive Programming (Flux and Mono) - Hands on + Junit Testing
In this section we will explore about how Flux and Mono works via code.
We will do live coding on how to write Junit test cases using Flux and Mono.
We will explore lot of different operators in Flux and Mono.
Build the first Non Blocking RESTFUL API using Annotated Controllers - Hands On
In this section we will build the first non blocking API using the annotated controllers.
This section covers the fundamentals of how the reactive API works.
This sections also covers the coding aspect of how to return a Flux/Mono from an end point.
This section also covers how to write JUNIT test cases using WebTestClient.
Build Non Blocking RESTFUL API using Functional Web - Hands On
In this section we will build the non blocking API using the Functional Web Module.
This sections explains about the RouterFunction and HandlerFunction which forms the foundation for Function Web Module.
This section also covers how to write JUNIT test cases using WebTestClient.
Spring WebFlux & Netty - Execution Model
This section explains about the different layers behind WebFlux to serve a HTTP Request/Response.
This sections covers the concepts of NETTY such as Channel, EventLoop and some of the technical aspects of Netty.
Overview of the Reactive API
This section will give you an Overview of the Reactive API that we are going to build as part of this course.
Reactive Programming in Databases - MongoDB - Hands On
In this section we will learn about how to write the reactive programming code with MongoDB.
Define the Item Document for the project.
This section covers about how to configure different profiles in Spring Boot.
In this section we will set up the ItemReactive Mongo DB adapter.
This section also covers how to write JUNIT test cases for the reactive repository.
Build the Item Reactive API Endpoint - Using RestController
In this section we will learn about how to code the Item CRUD Reactive API using the @RestController approach.
This section also covers how to write automated tests using JUNIT and the non blocking test client WebTestClient.
Build the Item Reactive API Endpoint - Using Functional Web
In this section we will learn about how to code the Item CRUD Reactive API using the Functional Web approach.
This section also covers how to write automated tests using JUNIT and the non blocking test client WebTestClient.
Build Non Blocking Client using WebClient
In this section we will explore the techniques to interact with Reactive API using the WebClient.
Learn the techniques to Invoke the Reactive API using exchange() and retrieve() methods.
We will explore the GET, PUT, POST and DELETE operations using the WebClient.
Handling Exceptions in WebFlux - RestController
In this section we will code and explore different approaches to handle the exceptions/errors that occurs in the reactive api that’s built using RestController.
Handle exceptions using @ExceptionHandler and @ControllerAdvice.
This section also covers how to write JUNIT test cases for the Exception scenarios.
Handling Exceptions in WebFlux - Functional Web
In this section we will code and explore different approaches to handle the exceptions/errors that occurs in the reactive api that’s built using Functional Web.
Handle exceptions using WebExceptionHandler.
This section also covers how to write JUNIT test cases for the Exception scenarios.
WebClient - Exception Handling
In this section we will code and explore how to handle the exceptions using the WebClient.
Learn the techniques to handle the exceptions using exchange() and retrieve() methods.
Streaming Real Time Data using WebFlux - Server Side Events (SSE)
In this section we will code and learn about build an endpoint for Streaming RealTime Data using Mongo DB and Spring WebFlux.
This section covers about the Tailable Cursors and Capped Collections in Mongo DB.
Build a Non Blocking Streaming Endpoint and interact with the Mongo DB using the @Tailable annotation.
Learn to write Automated Tests using JUNIT for the Streaming Endpoints (SSE).
- At least JDK 8
- Any one of the IDE like IntelliJ, Eclipse, etc.,
- Spring Boot Knowledge is a must to make the most out of this course
- Anyone who is willing to learn and build Reactive APIs using Spring WebFlux
What you'll learn:
- What problems Reactive Programming is trying to solve ?
- What is Reactive Programming?
- Reactive Programming using Project Reactor
- Learn to Write Reactive programming code with DB
- Learn to Write Reactive Programming with Spring
- Build a Reactive API from Scratch
- Learn to build Non-Blocking clients using WebClient
- Write end to end Automated test cases using JUNIT for the Reactive API
Watch Online Build Reactive RESTFUL APIs using Spring Boot/WebFlux
| # | Title | Duration |
|---|---|---|
| 1 | Course Introduction | 02:07 |
| 2 | Prerequisites | 01:04 |
| 3 | Why Reactive Programming ? | 08:59 |
| 4 | Traditional Rest API Design - How it works ? | 07:44 |
| 5 | What is Reactive Programming ? | 09:32 |
| 6 | Reactive Streams Specification | 07:58 |
| 7 | Reactive Libraries | 03:34 |
| 8 | Introduction to Project Reactor | 01:20 |
| 9 | Reactor Types - Flux and Mono | 07:31 |
| 10 | Project Setup | 07:11 |
| 11 | Flux - How it works ? | 12:15 |
| 12 | Flux - Learn to write JUNIT Tests | 10:17 |
| 13 | Mono - How it works and write Junit Tests | 04:44 |
| 14 | Flux/Mono - Exploring Factory methods | 16:39 |
| 15 | Filtering a Reactive Stream | 04:27 |
| 16 | Transforming a Reactive Stream using map | 08:28 |
| 17 | Transforming a Reactive Stream using flatMap | 17:17 |
| 18 | Combining Reactive Streams | 12:37 |
| 19 | Handling Errors in a Reactive Stream | 16:27 |
| 20 | Infinite Reactive Stream | 10:59 |
| 21 | Back Pressure - How it works ? | 14:23 |
| 22 | Push/Pull Communication Model | 01:09 |
| 23 | Hot vs Cold Reactive Streams | 08:10 |
| 24 | Virtualizing Time in Junit | 08:59 |
| 25 | How to get help ? | 01:55 |
| 26 | Introduction to Spring Boot 2 | 03:17 |
| 27 | Build the Simple Non Blocking API | 09:34 |
| 28 | Junit : Test for Non Blocking API using WebTestClient | 15:56 |
| 29 | Junit : Test for infinite Non Blocking Sequence API using WebTestClient | 08:59 |
| 30 | Build the simple Non Blocking API - Mono | 04:08 |
| 31 | Introduction to Functional Web in Spring WebFlux | 02:13 |
| 32 | Build the simple Non Blocking API using Handler and Router Functions | 10:13 |
| 33 | Junit : Test for Functional EndPoint using WebTestClient | 08:09 |
| 34 | Spring WebFlux - Behind the Scenes | 07:38 |
| 35 | Introduction to Netty - Channel, EventLoops | 06:58 |
| 36 | Netty - End to End, Threads, Execution Model | 06:32 |
| 37 | Application Overview | 01:54 |
| 38 | Setting up Mongo DB | 05:18 |
| 39 | Spring Profiles | 09:36 |
| 40 | Build the "Item" Document | 03:03 |
| 41 | Build the Reactive Item Mongo Repository | 02:01 |
| 42 | Reactive Mongo Repository operations using JUNIT - Read - Part1 | 12:23 |
| 43 | Reactive Mongo Repository operations using JUNIT - Read - Part2 | 05:01 |
| 44 | Reactive Mongo Repository operations using JUNIT - Custom Read Operation | 05:10 |
| 45 | Reactive Mongo Repository operations using JUNIT - Insert | 05:05 |
| 46 | Reactive Mongo Repository operations using JUNIT - Update | 04:50 |
| 47 | Reactive Mongo Repository operations using JUNIT - Delete | 08:25 |
| 48 | Build Artifact | 06:12 |
| 49 | Get All Items | 06:48 |
| 50 | Initialize the data using CommandLineRunner | 08:23 |
| 51 | Get All Items - JUNIT Test using WebTestClient - Part 1 | 09:34 |
| 52 | Get All Items - JUNIT Test using WebTestClient - Part 2 | 05:40 |
| 53 | Get a Single Item | 06:57 |
| 54 | Create an Item EndPoint | 06:09 |
| 55 | Delete an Item Endpoint | 04:32 |
| 56 | Update an Item Endpoint | 05:19 |
| 57 | Update an Item Endpoint - JUNIT | 09:23 |
| 58 | Setting up the Router Function and Handler Function for Item Reactive API | 02:18 |
| 59 | Get All Items - Functional Endpoint | 05:13 |
| 60 | Get All Items - JUNIT Test using WebTestClient | 02:55 |
| 61 | Get a Single Item - Functional Endpoint | 07:38 |
| 62 | Create an Item - Functional Endpoint | 04:36 |
| 63 | Delete an Item - Functional Endpoint | 03:30 |
| 64 | Update an Item - Functional Endpoint | 06:39 |
| 65 | Setting up the Item WebClient Project | 06:16 |
| 66 | Explore the retrieve() and exchange() in WebClient | 10:53 |
| 67 | Passing Path Variable using WebClient | 06:26 |
| 68 | Post call using WebClient | 05:39 |
| 69 | PUT call using WebClient | 06:24 |
| 70 | Delete call using WebClient | 03:53 |
| 71 | Handling Exceptions using @ExceptionHandler | 08:13 |
| 72 | Handling Exceptions using @ControllerAdvice | 03:06 |
| 73 | Handling Exceptions in Controller - JUNIT | 02:48 |
| 74 | Default Exception Behavior - Functional Web | 05:01 |
| 75 | Handling Exceptions using AbstractErrorWebExceptionHandler | 06:41 |
| 76 | Handling Exceptions in Functional Web - JUNIT | 02:54 |
| 77 | Handling Errors in WebClient - retrieve() | 08:08 |
| 78 | Handling Errors in WebClient - exchange() | 05:08 |
| 79 | What is a Streaming EndPoint ? | 02:35 |
| 80 | Setting up the Capped Collection - MongoDB | 05:08 |
| 81 | Build the Reactive ItemCapped Mongo Repository | 02:28 |
| 82 | Initialize the data using CommandLineRunner | 06:45 |
| 83 | Build the Stream Endpoint using Controller | 05:29 |
| 84 | JUNIT Test for Streaming endpoint using Controller | 07:54 |
| 85 | Build the Stream Endpoint using Functional Web | 05:38 |
| 86 | JUNIT Test for Streaming endpoint using Functional Web | 02:40 |
Similar courses to Build Reactive RESTFUL APIs using Spring Boot/WebFlux
Master Java Unit Testing with Spring Boot & Mockito
Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
Spring Boot Master Class
Build RESTFUL APIs using Kotlin and Spring Boot
Master Spring 6 Spring Boot 3 REST JPA Hibernate
RESTful Web Services, Java, Spring Boot, Spring MVC and JPA
Master Spring Boot 3 & Spring Framework 6 with Java
Spring Framework 5: Beginner to Guru
Spring 6 & Spring Boot 3 for Beginners (Includes 5 Projects)
