CF

Build Reactive RESTFUL APIs using Spring Boot/WebFlux

9h 34m 2s
English
Paid
Updated September 2026

Build Reactive RESTFUL APIs using Spring Boot/WebFlux is a 86-lesson 9 hours 34 minutes self-paced course by Udemy. The traditional Spring MVC request model has real limits under load, and this course is built around the alternative: reactive, non-blocking APIs using Spring WebFlux and Project Reactor.

Course facts

Lessons
86
Duration
9 hours 34 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Udemy
Price
Premium

The traditional Spring MVC request model has real limits under load, and this course is built around the alternative: reactive, non-blocking APIs using Spring WebFlux and Project Reactor.

Starting with the reactive types

You'll get hands-on with Flux and Mono, the two core reactive types, through live coding and JUnit testing, before moving on to build actual non-blocking REST endpoints – both with annotated controllers and with the functional RouterFunction/HandlerFunction approach.

Beyond the basics

  • How WebFlux serves requests on Netty, including channels and event loops
  • Connecting reactive APIs to MongoDB with reactive repositories
  • Exception handling across both controller-based and functional endpoints
  • Using WebClient to call other reactive APIs and handle errors
  • Server-sent events for real-time data, using tailable cursors and capped collections

Some familiarity with Spring Boot is recommended; by the end you'll understand not just how to write reactive code, but which real problems reactive programming actually solves.

Who teaches Build Reactive RESTFUL APIs using Spring Boot/WebFlux? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Build Reactive RESTFUL APIs using Spring Boot/WebFlux?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 86 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Course Introduction
All Course Lessons (86)
#Lesson TitleDurationAccess
1
Course Introduction Demo
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
Unlock unlimited learning

Get instant access to all 85 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Build Reactive RESTFUL APIs using Spring Boot/WebFlux?

More courses by Udemy

Frequently asked questions

What prerequisites are needed for this course?
Before enrolling, students should have a basic understanding of Java programming and familiarity with Spring Framework concepts. Knowledge of RESTful API design is beneficial but not mandatory, as the course provides an introduction to these topics.
What will I build during the course?
Throughout the course, you will build reactive applications using Spring WebFlux, including a non-blocking API and a reactive MongoDB repository. You will also create various endpoints for item management, such as creating, updating, and deleting items, and test these using JUnit and WebTestClient.
Who is the target audience for this course?
The course is designed for Java developers interested in learning about reactive programming and building non-blocking RESTful APIs. It is suitable for those who want to gain practical experience with Spring WebFlux and Project Reactor, as well as professionals looking to modernize their application architecture.
How does this course compare to traditional REST API courses?
Unlike traditional REST API courses that focus on blocking I/O operations using Spring MVC, this course emphasizes non-blocking, reactive programming using Spring WebFlux. It highlights the benefits of reactive systems, such as improved resource utilization and responsiveness, especially in high-concurrency environments.
Which specific tools and platforms will I learn to use?
The course covers tools and platforms like Spring Boot, Spring WebFlux, Project Reactor, and MongoDB. You'll learn how to use WebClient for building non-blocking clients and JUnit for testing reactive components. The course also introduces Netty, which serves as the underlying server for Spring WebFlux applications.
What topics are not covered in this course?
The course focuses on reactive programming with Spring WebFlux and does not cover traditional synchronous RESTful API development using Spring MVC in detail. Additionally, it does not delve into advanced database management or front-end development frameworks.
How much time should I expect to commit to this course?
The course consists of 86 lessons, and while the total runtime isn't specified, students should allocate ample time for both video lectures and hands-on exercises. The course is designed to be practical, so expect to spend additional time coding and testing your applications beyond just watching the lessons.