Design Patterns With Spring WebFlux

Integration & Resilient Design Patterns to build Reactive Microservices
Design Patterns With Spring WebFlux
File Size :
2.43 GB
Total length :
8h 28m



Vinoth Selvaraj


Last update




Design Patterns With Spring WebFlux

What you’ll learn

Advanced Spring WebFlux
Reactive Microservices
Circuit Breaker Pattern
Rate Limiter Pattern
Bulkhead Pattern
Timeout Pattern
Retry Pattern
Gateway Aggregator Pattern
Scatter Gather Pattern
Orchestrator Pattern
Splitter Pattern

Design Patterns With Spring WebFlux


Knowledge on Reactive Programming
Knowledge on Spring WebFlux
Comfortable with Indian Accent ๐Ÿ™‚


This is the 5th course in the Reactive Course SeriesSpring WebFlux is a reactive non-blocking web stack which scales better & provides better performance compared to traditional Spring Web MVC! In this course, we learn various integration and resilient design patterns with Spring WebFlux to build Reactive Microservices.By the end of this course you would be comfortable with:Integration Patterns:Handling multiple reactive microservices communication in a much better way!Gateway Aggregator PatternAim of this pattern is to reduce the network latency when a client needs to communicate with multiple backend services to perform an operation & also to act like a facade for the complex backend services.Scatter Gather PatternAim of this pattern is to route a request message to the number of backend services. It then uses an Aggregator to collect the responses.Orchestrator Pattern (SAGA – for parallel workflow)Aim of this pattern is to orchestrate multiple backend services to provide a complex workflow. Take an e-commerce application in which we have payment service, inventory service, shipping service etc. An order can be fulfilled only when all these services return success response. What needs to be done when payment is success but shipping failed or vice versa. How to handle such complex transactions which spans multiple microservices? Orchestrator Pattern (for sequential workflow)This is same as above. But for a slightly different use case where we provide sequential workflow. Use this pattern to replace chained microservice calls.Splitter PatternAim of this pattern to consume one message containing a list of repeating elements, each of which can be processed individually. Resilient Patterns:How to create more robust & resilient reactive microservices.Timeout PatternAim of this pattern is to make your service more resilient when the remote service is not responding to your requests in a timely manner.Retry PatternTo create more robust service which handles intermittent network issues or the remote services issues.Circuite Breaker PatternAim of this pattern is to protect your services and meet SLAs when dependent remote services are not healthy or not reachable.Rate Limiter PatternHow to protect your services from DDoS attack? How to limit the remote network calls to keep the price within the budget etcBulkhead PatternAim of this pattern is to allocate a set of resources to your services based on the priority. So that a problem in one feature does not bring the entire application down.


Section 1: Introduction

Lecture 1 [MUST WATCH]: What will you learn from this course?

Lecture 2 [Optional] – Reactive Series

Lecture 3 Source Code

Section 2: Gateway Aggregator Pattern

Lecture 4 Gateway Aggregator Pattern – Intro

Lecture 5 Jar Download

Lecture 6 External Services

Lecture 7 Project Setup

Lecture 8 Creating DTO

Lecture 9 Creating External Service Clients

Lecture 10 Aggregator Service

Lecture 11 Aggregator Controller

Lecture 12 Gateway Aggregator Pattern Demo

Lecture 13 Is our Aggregator resilient?

Lecture 14 Making Aggregator more resilient!

Lecture 15 Are we making parallel calls?

Lecture 16 Product Service error handling

Lecture 17 Summary

Section 3: Scatter Gather Pattern

Lecture 18 Scatter Gather Pattern – Intro

Lecture 19 External Services

Lecture 20 Creating DTO

Lecture 21 Creating Delta Service Client

Lecture 22 Creating JetBlue / Frontier Service Client

Lecture 23 Creating Service

Lecture 24 Creating Controller

Lecture 25 Scatter Gather Demo

Lecture 26 Summary

Section 4: Orchestrator Pattern (For Parallel Workflow)

Lecture 27 Orchestrator Pattern – Intro

Lecture 28 Orchestrator Scope

Lecture 29 External Services

Lecture 30 Creating DTO – Part 1

Lecture 31 Creating DTO – Part 2

Lecture 32 Creating Service Clients – Part 1

Lecture 33 Creating Service Clients – Part 2

Lecture 34 Orchestrator Request Context

Lecture 35 Util Class

Lecture 36 Orchestrator Pattern Implementation – High Level Architecture

Lecture 37 Payment Handler

Lecture 38 Inventory and Shipping Handlers

Lecture 39 Order Fulfillment Service

Lecture 40 Order Cancellation Service

Lecture 41 Order Orchestrator Service

Lecture 42 Debug Util

Lecture 43 Controller

Lecture 44 Orchestrator Demo

Lecture 45 Bug Fix

Lecture 46 Quick Note

Lecture 47 Summary

Section 5: Orchestrator Pattern (For Sequential Workflow)

Lecture 48 Sequential Workfkow – Intro

Lecture 49 External Services

Lecture 50 Project Setup

Lecture 51 Creating DTO

Lecture 52 Creating Service Clients

Lecture 53 Util Class

Lecture 54 Sequential Workflow – Architecture

Lecture 55 Sequential Workflow – Implementation – Part 1

Lecture 56 Sequential Workflow – Implementation – Part 2

Lecture 57 Sequential Workflow – Implementation – Part 3

Lecture 58 Sequential Workflow – Demo

Section 6: Splitter Pattern

Lecture 59 Splitter Pattern – Intro

Lecture 60 External Services

Lecture 61 Creating DTO – Part 1

Lecture 62 Creating DTO – Part 2

Lecture 63 Creating Service Clients

Lecture 64 Quick Note On Flux Requests

Lecture 65 [Courses] – For Streaming Requests and Responses

Lecture 66 Abstract Reservation Handler

Lecture 67 Car Reservation Handler

Lecture 68 Room Reservation Handler

Lecture 69 Reservation Service

Lecture 70 Controller

Lecture 71 Splittern Pattern – Demo

Section 7: Timeout Pattern

Lecture 72 Resiliency Pattern – Intro

Lecture 73 Timeout Pattern

Lecture 74 Project Setup

Lecture 75 Timeout Pattern Implementation

Lecture 76 Timeout Pattern Demo

Lecture 77 Summary

Section 8: Retry Pattern

Lecture 78 Retry Pattern – Intro

Lecture 79 External Services

Lecture 80 Project Setup

Lecture 81 Retry Pattern Implementation Demo

Lecture 82 4XX Issue Fix

Lecture 83 Quick Note On Retry Spec

Lecture 84 Summary

Section 9: Circuit Breaker Pattern

Lecture 85 Circuit Breaker Pattern – Intro

Lecture 86 Circuit Breaker Terminologies

Lecture 87 External Services

Lecture 88 Project Setup

Lecture 89 Maven Dependencies

Lecture 90 Resilience4j – Config

Lecture 91 Circuit Breaker Pattern Implementation

Lecture 92 Circuit Breaker Pattern Demo

Lecture 93 Overriding Configuration

Lecture 94 Summary

Section 10: Rate Limiter Pattern

Lecture 95 Rate Limiter Pattern – Intro

Lecture 96 Server Side Rate Limiter – Implementation

Lecture 97 Server Side Rate Limiter – Demo

Lecture 98 Client Side Rate Limiter – Implementation

Lecture 99 Summary

Section 11: Bulkhead Pattern

Lecture 100 Bulkhead Pattern – Intro

Lecture 101 Project Setup

Lecture 102 Problem Demo

Lecture 103 Why It happens?

Lecture 104 Bulkhead Pattern Implementation

Lecture 105 Summary

Section 12: Thank You

Lecture 106 Thank You

Any Developer / Architect who is interested in Microservice Development / Architecture with WebFlux

Course Information:

Udemy | English | 8h 28m | 2.43 GB
Created by: Vinoth Selvaraj

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top