Introduction to Reactive Spring

Reactive Spring focuses on providing an understanding of the fundamental principles and technologies that are used in reactive programming. This understanding is critical to being able to diagnose,...

Read More
$1,000 USD GSA  $2,353.15
Course Code TT3355
Duration 4 days
Available Formats Classroom
7096 Reviews star_rate star_rate star_rate star_rate star_half

“It was a pleasure taking this course from Peter. I was definitely the least experienced out of our group, and he made sure to check in with me so that I wasn't completely lost. Wishing the best for him, his wife, his daughter, and their dog!”

Course Image

Reactive Spring focuses on providing an understanding of the fundamental principles and technologies that are used in reactive programming. This understanding is critical to being able to diagnose, troubleshoot, tune, and perform other lifecycle activities. Geared for experienced Java developers with basic Spring experience, Introducition to Reactive Spring explores concurrent, asynchronous and reactive programming APIs and techniques using Spring. Throughout the hands-on course, students will explore reactive programming essentials, Reactive Streams and the Project Reactor APIs, as well as how these APIs are integrated into Spring. Spring 5 includes Spring WebFlux, providing a reactive programming model for web applications, as well as support for Reactive REST APIs. Students will also learn about Spring WebSocket, which assists in the creation of web applications to provide a full-duplex, two-way communication between client and server. The course also covers Spring Data, which implements database operations relying on Reactive Programming APIs. While the Spring R2DBC initiative aims to bring reactive programming to relational databases, several NoSQL databases already provide this possibility. Along with an introduction to NoSQL and the MongoDB, this courses also explores the APIs available to communicate with this NoSQL database using both blocking and reactive APIs.

Skills Gained

Working in a hands-on learning environment, guided by our expert team, attendees will learn to:

  • Understand the ReactiveX specification
  • Understand the basics of Reactive Programming
  • Discuss the advantages and limitations of Observables
  • Write a client application capable of handling Reactive events
  • Apply operators to event streams to filter, modify and combine the objects emitted by event publishers
  • Select the appropriate type of Event Source
  • Use both Cold and Hot Observables
  • Deal with backpressure problems in reactive programming
  • Develop a reactive web application using Spring WebFlux
  • Define application flows of a WebFlux application
  • Use the WebClient API to work with both synchronous and streaming APIs
  • Develop Unit and Integration tests to test WebFlux endpoints
  • Creating a reactive REST endpoint
  • Become familiar with the basics of WebSockets
  • Create a WebSocket endpoint using Spring
  • Create a WebSocket client
  • Understand the basics of NoSQL
  • Become familiar with the basics of MongoDB
  • Understand how the data in MongoDB can be retrieved using a Reactive API
  • Define Spring Data MongoDB repositories
  • Query the MongoDB using Spring Data
  • Define a reactive repository using MongoDB
  • Explore the experimental Spring Data R2DBC API to perform reactive CRUD operations against a relational database

Who Can Benefit

This in an introduction to Reactive Spring course for intermediate-skilled Java developers with incoming Spring experience. This course in not for developers new to Java, or new to Spring.


Students should have development skills at least equivalent to the following course(s) or should have attended as a pre-requisite:

  • TT3325 – Core Spring 5.x essentials
  • TT3356 – Working with Spring Core, Spring Boot & Spring Batch
  • TT3359 – Spring Boot 2.x and Spring Data

Course Details

Session: Introduction to Reactive Programming

Lesson: Introduction

  • Reactive Manifesto,
  • Introduce ReactiveX
  • ReactiveX implementations
  • The Observer and Iterator pattern and functional programming
  • Discuss hot and cold observables

Lesson: Reactive Streams API

  • Introduce the Reactive Streams specification
  • Publisher and Subscribers
  • java.util.concurrent.Flow
  • Transformation of Messages (Processor)
  • Controlling messages

Session: Project Reactor

Lesson: Introduction

  • Introduce the Reactor Building blocks
  • Flux and Mono
  • Creating observables
  • Subscribing to a stream

Lesson: Reactive Operators

  • Introduce Operators
  • Show the use of RxMarbles (marble diagrams)
  • Explain some commonly used operators
  • Callback operators

Lesson: Schedulers (Multithreading)

  • Thread usage of subscriber and consumer
  • Using the subscribeOn method
  • Introduce the Scheduler interface
  • Using the observeOn method

Lesson: Backpressure

  • Strategies for dealing with Backpressure
  • “reactive pull” backpressure
  • ConnectableFlux
  • Throtteling

Lesson: Exception Handling

  • Handling errors in onError
  • Exception handling strategies
  • Using onErrorReturn or onErrorNext operators
  • Using the retry operators
  • The Global Error Handler

Spring WebFlux

Lesson: Introduction

  • Annotated Controllers
  • Functional Endpoints
  • WebFlux configuration
  • Defining reactive web endpoints

Lesson: View Technologies

  • View technologies
  • Using Thymeleaf to create the view
  • View Configuration

Lesson: Defining flows

  • Defining the application flow
  • Actions
  • Defining decision
  • Navigating flows
  • RouterFunction

Session: Spring WebClient

Lesson: Introduction to WebClient

  • Working with asynchronous and streaming APIs
  • Making requests
  • Handling the response

Lesson WebTestClient

  • Testing WebFlux server endpoints
  • Testing controllers or functions
  • Define integration tests

Session: Spring Reactive REST APIs

Lesson: Reactive REST services

  • Creating a reactive REST endpoint
  • Creating a reactive client for Reactive streams

Session: Spring Reactive WebSockets

Lesson: Introduction to WebSockets

  • Be familiar with the basics of WebSockets
  • Understand the HTTP handshake and upgrade
  • Name some of the advantages of WebSockets

Lesson: Defining the WebSocket

  • WebSocket Message Handling
  • WebSocketSession
  • Implemeting the WebSockethandler
  • Creating a Browser WebSocket Client

Session: NOSQL and MongoDB

Lesson: BigData

  • Introduce Big Data
  • Explain the need for enhanced data storage

Lesson: Introduction to NoSQL

  • Introduce NoSQL
  • Discuss different types of data stores
  • ACID vs BASE
  • CAP (Brewer’s) Theorem
  • Eventual Consistency

Lesson: Introduction to MongoDB

  • JavaScript Object Notation Overview
  • Introduce Binary JSON (BSON)
  • Starting the database
  • Creating Collections and Documents
  • Executing ‘simple’ database commands
  • Introduce the ObjectID
  • Searching for documents using query operators
  • Updating and deleting documents
  • MongoDB Compass

Session: Spring and MongoDB

Lesson: Spring and MongoDB

  • MongoDB Support in Spring Data
  • MongoClient and MongoTemplate
  • Spring Data MongoDB configuration
  • Adding documents to the database
  • The @Document and @Field annotations
  • Polymorphism and the _class property

Lesson: Spring Data MongoDB

  • MongoRepository
  • @EnableMongoRepositories
  • Field naming strategy

Lesson: Spring MongoDB Queries

  • Using JSON queries to find documents
  • The Criteria object
  • The @PersistenceConstructor annotation

Lesson: Reactive Repositories with MongoDB

  • Using Reactive repositories
  • ReactiveMongoTemplate
  • ReactiveCrudRepository

Spring Data R2DBC (Experimental)

Lesson: R2DBC

  • Reactive Relational Database Connectivity
  • DatabaseClient
  • Performing CRUD operations
  • Reactive Query annotated methods
Contact Us 1-800-803-3948
Contact Us
FAQ Get immediate answers to our most frequently asked qestions. View FAQs arrow_forward