Spring WebFlux Masterclass- Reactive Microservices [2024]

Spring WebFlux Masterclass: Reactive Microservices [2024], available at $84.99, has an average rating of 4.67, with 345 lectures, based on 1390 reviews, and has 13379 subscribers.

You will learn about Spring WebFlux From Scratch Reactive Microservices Performance Comparison – Traditional vs Reactive Achieving High Performance & Scalability With HTTP2 Streaming API With Back-Pressure Reactive Relational DB Connectivity R2DBC Server Sent Events WebClient Functional Endpoints WebFilters / Interceptors Integration Testing This course is ideal for individuals who are Any Developer / Architect who is interested in Microservice Development / Architecture with WebFlux It is particularly useful for Any Developer / Architect who is interested in Microservice Development / Architecture with WebFlux.

Enroll now: Spring WebFlux Masterclass: Reactive Microservices [2024]

Summary

Title: Spring WebFlux Masterclass: Reactive Microservices [2024]

Price: $84.99

Average Rating: 4.67

Number of Lectures: 345

Number of Published Lectures: 192

Number of Curriculum Items: 345

Number of Published Curriculum Objects: 192

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Spring WebFlux From Scratch

Reactive Microservices

Performance Comparison – Traditional vs Reactive

Achieving High Performance & Scalability With HTTP2

Streaming API With Back-Pressure

Reactive Relational DB Connectivity R2DBC

Server Sent Events

WebClient

Functional Endpoints

WebFilters / Interceptors

Integration Testing

Who Should Attend

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

Target Audiences

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

Prerequisite: Knowledge on Reactive Programming.

Course Focus

This course provides a comprehensive introduction to Spring WebFlux, a framework for building highly scalable, resilient and responsive web applications using reactive programming principles.

What You’ll Learn

Traditional vs Reactive APIs

How Reactive APIs are different from Traditional APIs.

Reactive Data Access R2DBC

Learn to connect to relational databases reactively using R2DBC drivers, create reactive repositories with Spring Data R2DBC, implement CRUD operations with reactive data access patterns, and effectively integration test your data access layer.

Running a throughput/efficiency test to demonstrate the power of R2DBC, its throughput and how it uses the system resources more efficiently compared to Spring Data JPA.

Building CRUD Operations

Master creating reactive controllers with Spring WebFlux annotations, handling requests and responses with Flux and Mono, integration testing your reactive controllers.

Error Handling Strategies

Discover techniques for managing exceptions within reactive pipelines using various operators. Learn how to return meaningful error responses for a robust user experience.

WebFilter/Interceptor Chaining

Explore how to implement WebFilters for pre-processing and post-processing requests and responses. Chain multiple WebFilters for complex logic, pass attributes from WebFilters to controllers, and share data effectively.

Functional Programming with WebFlux

Leverage the power of lambda expressions to write concise and readable code. Build reactive controllers with functional endpoints and understand the benefits of functional programming within WebFlux.

Building Reactive Clients

Learn to use WebClient to build reactive clients that consume external APIs using reactive streams and handle asynchronous responses efficiently in a non-blocking manner.

Streaming

Implement client-side streaming for uploading data as a stream using WebClient and explore backpressure handling for optimized data transfer.

Implement server-side streaming for downloading data as a stream using WebClient.

Implement Server-Sent Events (SSE) with Spring WebFlux to enable real-time data updates from server to client.

Optimizing for Performance

Gzip compression

HTTP connection pooling to optimize bandwidth usage and application scalability.

Leveraging HTTP/2 protocol for efficient communication (New!).

Integration Testing

Master integration testing with WebTestClient, combining testing practices into our learning process throughout the course.

Course Structure

Focus on practical code examples and demos tailored to each module’s specific topic.

Hands-on labs to solidify your learning throughout the course.

Access to resources for further learning on both Spring WebFlux and prerequisite reactive programming concepts (articles, tutorials, official documentation).

By the end of this course, you’ll be equipped with the knowledge and skills to build modern, performant, and scalable web applications using Spring WebFlux.

Note

A basic understanding of reactive programming is assumed as a prerequisite for this course.

Join this course to master Spring WebFlux and unlock the potential of reactive programming for developing highly performant and scalable microservices. Gain the skills necessary to build resilient, efficient, and real-time applications using Spring WebFlux’s non-blocking and event-driven architecture.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Before You Enroll

Chapter 2: Traditional vs Reactive APIs

Lecture 1: *** Resource ***

Lecture 2: Project Setup

Lecture 3: External Services

Lecture 4: Traditional vs Reactive API

Lecture 5: Traditional vs Reactive API – Demo

Lecture 6: Traditional vs Reactive API – Demo via Browser

Lecture 7: Exposing Streaming API

Lecture 8: Common Mistake Using Reactive Pipeline

Lecture 9: How Reactive Web Works – Step By Step

Lecture 10: FAQ – Should Entire Stack Be Reactive?

Lecture 11: Reactive Web is Resilient – Demo

Lecture 12: Summary

Chapter 3: Spring Data R2DBC

Lecture 1: Introduction

Lecture 2: Connection String

Lecture 3: *** Resource *** – Database Initialization Scripts

Lecture 4: Project Setup

Lecture 5: Spring Data – Crash Course

Lecture 6: Customer Entity / Repository

Lecture 7: Step Verifier – Crash Course

Lecture 8: CRUD Using Repository – Part 1

Lecture 9: CRUD Using Repository – Part 2

Lecture 10: CRUD Using Repository – Part 3

Lecture 11: R2DBC – Show SQL

Lecture 12: *** Assignment *** – Price Range Query Method

Lecture 13: Pageable

Lecture 14: What About Complex Queries?

Lecture 15: *** Resource *** – SQL For Products Ordered By Customer

Lecture 16: Join Query Using @Query

Lecture 17: *** Resource *** – SQL For Projection

Lecture 18: Projection

Lecture 19: R2DBC Database Client

Lecture 20: Summary

Chapter 4: R2DBC vs JPA/JDBC

Lecture 1: Introduction

Lecture 2: [Performance Test] Throughput / Efficiency

Lecture 3: How R2DBC Works

Lecture 4: FAQ – Can I Use Spring Data JPA?

Lecture 5: Reactive Manifesto

Chapter 5: Reactive CRUD APIs

Lecture 1: Introduction

Lecture 2: FAQ – Do We Need DTOs?

Lecture 3: DTO / Entity / Repository

Lecture 4: Service Class Implementation

Lecture 5: Controller

Lecture 6: FAQ – @RequestBody Mono<T> vs T

Lecture 7: CRUD APIs Demo

Lecture 8: Mono/Flux – Response Entity

Lecture 9: Handling 4XX via Response Entity

Lecture 10: @Modifying Query

Lecture 11: Paginated Results

Lecture 12: CRUD APIs Demo

Lecture 13: WebTestClient – Introduction

Lecture 14: Integration Testing – Part 1

Lecture 15: Integration Testing – Part 2

Lecture 16: Integration Testing – Part 3

Lecture 17: POST / PUT – Body Publisher vs Body Value

Lecture 18: Summary

Chapter 6: Input Validation / Error Handling

Lecture 1: Problem Detail

Lecture 2: What About Bean Validation?

Lecture 3: Project Setup

Lecture 4: Application Exceptions

Lecture 5: Request Validator

Lecture 6: Validation – Emitting Error Signal

Lecture 7: @ControllerAdvice

Lecture 8: Demo via Postman

Lecture 9: *** Assignment ***

Lecture 10: Integration Tests

Lecture 11: Summary

Chapter 7: WebFilter

Lecture 1: Introduction

Lecture 2: WebFilter Chain – How It Works

Lecture 3: Authentication & Authorization Requirements

Lecture 4: WebFilter Implementation

Lecture 5: Attributes via WebFilter

Lecture 6: WebFilter Demo

Lecture 7: Accessing Attributes via @Controller

Lecture 8: Problem Detail – WebFilter Workaround

Lecture 9: *** Assignment ***

Lecture 10: Integration Tests

Lecture 11: Summary

Chapter 8: Functional Endpoints

Lecture 1: Introduction

Lecture 2: Router Configuration – Part 1

Lecture 3: Request Handler

Lecture 4: Router Configuration – Part 2

Lecture 5: Input Validation / Error Handler

Lecture 6: Paginated Results

Lecture 7: Order Of The Routes

Lecture 8: Demo via Postman

Lecture 9: Integration Tests

Lecture 10: Multiple Router Functions

Lecture 11: Nested Router Functions

Lecture 12: What About WebFilters

Lecture 13: Request Predicates

Lecture 14: *** Assignment ***

Instructors

Vinoth Selvaraj
Principal Engineer

Rating Distribution

1 stars: 6 votes

2 stars: 13 votes

3 stars: 89 votes

4 stars: 445 votes

5 stars: 837 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!