Spring Data reative allow us to implement database operations relying on Reative Programming APIs. While the Spring R2DBC initiative aims to bring reactive programming to relational databaes, several NoSQL databases already provide this possibility. After an introduction to NoSQL and the MongoDB, this courses covers the APIs available to communicate with this NoSQL database using both blocking and reactive APIs. Introdcution to Reactive Spring is a comprehensive Java training workshop geared for experienced developers who wish to explore concurrent, asynchronous and reactive programming APIs and techniques using Spring. After an introduction to reactive programming, Reactive Streams and the Project Reactor APIs, this course will show how this APIs are integrated into Spring.


* Actual course outline may vary depending on offering center. Contact your sales representative for more information.

Learning Objectives

Working within in an engaging, hands-on learning environment, guided by our expert team, attendees will:
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 Spring Data R2DBC API to perform reactive CRUD operations against a relational database

  • Introduction to Reactive Programming

  • Reactive Manifesto

    Introduce ReactiveX

    ReactiveX implementations

    The Observer, Iterator pattern and functional programming

    Discuss hot and cold publishers

  • Reactive Streams API

  • Introduce the Reactive Streams specification

    Publisher and Subscribers


    Transformation of Messages (Processor)

    Controlling messages

    Tutorial: Setup Eclipse for Using Maven

  • Introduction

  • Introduce the Reactor Building blocks

    Flux and Mono

    Creating observables

    Subscribing to a stream

  • Testing Event Sources (introduction)

  • Testing reactive implementations

    StepVerifier : test sequence of emitted items

    Defining expectations

    TestPublisher: produce test data to test downstream operators

  • Reactive Operators

  • Introduce Operators

    Show the use of marble diagrams

    Explain some commonly used operators

    Callback operators

  • Schedulers (Multithreading)

  • Thread usage of subscriber and consumer

    Using the subscribeOn method

    Introduce the Scheduler interface

    Using the observeOn method

  • Backpressure

  • Strategies for dealing with Backpressure

    “reactive pull” backpressure

  • Exception Handling

  • Handling errors in onError

    Exception handling strategies

    Using onErrorReturn or onErrorNext operators

    Using the retry operators

    The Global Error Handler

  • Spring Data Review

  • Quick review of Spring Data repositories

    Query return types

    Defining Query methods

    Pagination and sorting

  • R2DBC

  • Reactive Relational Database Connectivity


    Performing CRUD operations

    Reactive Query annotated methods

  • Spring WebFlux: Introduction

  • Annotated Controllers

    Functional Endpoints

    WebFlux configuration

    Creating a reactive REST endpoint

  • Defining flows

  • Defining the application flow


    Defining decision

    Navigating flows


  • View Technologies

  • View technologies

    Using Thymeleaf to create the view

    View Configuration

  • Spring WebClient: Introduction to WebClient

  • Working with asynchronous and streaming APIs

    Making requests

    Handling the response

    Lab: WebClient

  • WebTestClient

  • Testing WebFlux server endpoints

    Testing controllers or functions

    Define integration tests

  • Introduction to Spring Reactive WebSockets

  • Be familiar with the basics of WebSockets

    Understand the HTTP handshake and upgrade

    Name some of the advantages of WebSockets

  • Defining the WebSocket

  • WebSocket Message Handling


    Implementing the WebSockethandler

    Creating a Browser WebSocket Client

  • WebSocket STOMP

  • Streaming (or Simple) text-orientated messaging protocol

    Introduce SockJS

    Connecting to the STOMP endpoint

    Configuring the message broker

    STOMP destinations

  • Reactive WebSocket

  • Reactive WebSocket support

    Implement the reactive WebSocketHandler

  • BigData

  • Introduce Big Data

    Explain the need for enhanced data storage

  • 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

  • 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

    The Criteria object

  • Spring Data MongoDB

  • MongoRepository

    Field naming strategy

    Using JSON queries to find documents

    The @PersistenceConstructor annotation

  • Reactive Repositories with MongoDB

  • Using reactive repositories


    RxJava or Reactor


This in an intermediate-level Java development course geared for students experienced with Java and Spring programming essentials. This course does not cover Java or Spring development basics.




Students should have development skills at least equivalent to the following course(s) or should have attended as a pre-requisite: TT3335 Mastering Spring 5.x


Length: 4.0 days (32 hours)


Not Your Location? Change

Course Schedule:

Schedule select
10:00 AM ET -
6:00 PM ET
Filling Fast