Build Reactive MicroServices using Spring WebFlux/SpringBoot

Build Reactive MicroServices using Spring WebFlux/SpringBoot, available at $84.99, has an average rating of 4.52, with 202 lectures, based on 5239 reviews, and has 34874 subscribers.

You will learn about 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 This course is ideal for individuals who are Anyone who is willing to learn and build Reactive APIs using Spring WebFlux It is particularly useful for Anyone who is willing to learn and build Reactive APIs using Spring WebFlux.

Enroll now: Build Reactive MicroServices using Spring WebFlux/SpringBoot

Summary

Title: Build Reactive MicroServices using Spring WebFlux/SpringBoot

Price: $84.99

Average Rating: 4.52

Number of Lectures: 202

Number of Published Lectures: 117

Number of Curriculum Items: 211

Number of Published Curriculum Objects: 124

Original Price: ₹6,900

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

Anyone who is willing to learn and build Reactive APIs using Spring WebFlux

Target Audiences

Anyone who is willing to learn and build Reactive APIs using Spring WebFlux

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, POSTand 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 DBand 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).

Course Curriculum

Chapter 1: Getting Started with the Course

Lecture 1: Course Introduction

Lecture 2: Prerequisites

Chapter 2: Source Code and Course Slides for this Course

Lecture 1: Source Code

Lecture 2: Course Slides

Chapter 3: Why Reactive Programming ?

Lecture 1: Why Reactive Programming – Part 1?

Lecture 2: Why Reactive Programming – Part 2?

Chapter 4: Introduction to Reactive Programming

Lecture 1: What is Reactive Programming ?

Lecture 2: Introduction to Reactive Streams

Chapter 5: Introduction to Spring WebFlux

Lecture 1: Non-Blocking(Reactive) RestFul API using Spring WebFlux

Chapter 6: Getting Started with Project Reactor

Lecture 1: Introduction to Project Reactor

Lecture 2: Reactor Reactive Types – Flux and Mono

Chapter 7: Setting up the base project for this course

Lecture 1: Project SetUp

Chapter 8: Lets Explore Flux and Mono – Hands On

Lecture 1: Let's write our very first Flux

Lecture 2: Let's write our very first Mono

Lecture 3: Reactive Stream Events

Lecture 4: Testing Flux using JUnit5

Lecture 5: Transforming Data Using Operators in Project Reactor

Lecture 6: Transform using map() Operator

Lecture 7: Reactive Streams are Immutable

Lecture 8: Filter using filter() Operator

Lecture 9: Advanced transform using the flatMap() Operator

Lecture 10: Asynchronous Operations using flatMap() Operator

Lecture 11: Advanced transform using the concatMap() Operator

Lecture 12: flatMap( ) operator in Mono

Lecture 13: flatMapMany( ) operator in Mono

Lecture 14: Transform using the transform() Operator

Lecture 15: Handling empty data using defaultIfEmpty and switchIfEmpty() Operators

Lecture 16: Introduction to Combining Reactive Streams

Lecture 17: Combining Reactive Streams using concat and concatWith Operator

Lecture 18: Combining Reactive Streams using merge() and mergeWith() Operators

Lecture 19: Combining Reactive Streams using mergeSequential() operator

Lecture 20: Combining Reactive Streams using zip and zipWith() Operator

Chapter 9: Introduction to Spring WebFlux

Lecture 1: Introduction to Spring WebFlux

Lecture 2: What are we going to build in this Course ?

Chapter 10: Set up the MoviesInfoService Service

Lecture 1: Project SetUp

Chapter 11: Simple Non Blocking RESTFUL API using Annotated Controller Approach

Lecture 1: Build a Simple Non Blocking API – Flux

Lecture 2: Build a simple Non Blocking API – Mono

Lecture 3: Build Infinite Streams API (SSE)

Chapter 12: Automated Tests using JUnit5 and @WebFluxTest

Lecture 1: Introduction to Automated Tests

Lecture 2: Testing Spring Webflux Endpoint using@WebFlux Test Annotation

Lecture 3: Different Approaches of Testing an Endpoint

Lecture 4: JUnit Test for the Mono Endpoint

Lecture 5: JUnit Test Streaming Endpoint – SSE

Chapter 13: Reactive Programming in Mongo DB for the MovieInfo Service

Lecture 1: Set up the MovieInfo Document

Lecture 2: Configure the ReactiveMongoDB Repository for MovieInfo Document

Lecture 3: Configure the Mongo DB server details in the application.yml file

Lecture 4: Setup the Integration Test using @DataMongoTest

Lecture 5: Write Integration Test for findAll() MovieInfo Document

Lecture 6: Write Integration Test for findById() MovieInfo Document

Lecture 7: Write Integration Test for saving the MovieInfo Document

Lecture 8: Write Integration Test for updating the MovieInfo Document

Lecture 9: Write Integration Test for deleting the MovieInfo Document

Chapter 14: Build MovieInfo Service using Rest Controller Approach

Lecture 1: Build a POST endpoint to create a new MovieInfo

Lecture 2: Integration Test for the POST end point using JUnit5

Lecture 3: Build a GET Endpoint to get all the MoviesInfo

Lecture 4: Build a GET Endpoint to retrieve a MovieInfo by ID

Lecture 5: Build a PUT Endpoint to update a MovieInfo by ID

Lecture 6: Build the DELETE endpoint to delete a MovieInfo by ID

Chapter 15: Unit Testing in Spring WebFlux

Lecture 1: Setting up the UnitTest in WebFlux

Lecture 2: Unit Test for GetAllMovieInfos endpoint – GET

Lecture 3: Unit Test for the create MovieInfo Endpoint – POST

Lecture 4: Unit Test for the update MovieInfo Endpoint – PUT

Chapter 16: Bean Validation using Validators and ControllerAdvice

Lecture 1: Bean Validation for Name,Year with @NotBlank and @Positive Annotation Validators

Lecture 2: Customize the Default Error handling using ControllerAdvice

Lecture 3: Bean Validation for List Field using @NotBlank Annotation

Chapter 17: Using ResponseEntity with Reactive Types

Lecture 1: Need for ResponseEntity in Spring WebFlux

Lecture 2: Using ResponseEntity to dynamically change the Response Status

Chapter 18: Writing Custom Queries using ReactiveMongoRepository

Lecture 1: Implement a Custom Query to retrieve MovieInfo by Year

Lecture 2: GET Endpoint to retrieve a MovieInfo by Year – Using @RequestParam

Chapter 19: Spring WebFlux Under the Hood – Netty and Threading Model

Lecture 1: How Netty works with Spring Webflux ?

Lecture 2: How does Netty handle the Request ?

Chapter 20: Introduction to Functional Web Module in Spring WebFlux

Lecture 1: Introduction to Functional Web

Lecture 2: Build a simple RestFul API using Functional Web

Chapter 21: Build MoviesReview Service using Functional Web

Lecture 1: Set up the Repository Class for the Review Document

Instructors

Pragmatic Code School
Technology Enthusiast, Online Instructor

Rating Distribution

1 stars: 42 votes
2 stars: 90 votes
3 stars: 506 votes
4 stars: 2036 votes
5 stars: 2565 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!

Menu