Build Reactive MicroServices

using
Spring WebFlux/SpringBoot
Dilip
 About Me

• Dilip

• Building Software’s since 2008

• Teaching in UDEMY Since 2016

What’s Covered ?
• Introduction to Reactive Programming

• Advantages of Reactive Programming over traditional programming models

• Writing Reactive Programming code using Project Reactor

• Introduction Spring WebFlux

• Reactive Services using Spring WebFlux

• Three Reactive Rest Services using Spring WebFlux

• JUnit test cases using JUnit5

Targeted Audience
• Any Developer who is curious to learn about Reactive Programming

• Any Developer who is interested in learning Spring WebFlux

• Any Developer who is interested in Building Reactive(Non Blocking) APIs

Source Code
Thank You!
Why Reactive Programming ?
Evolution of Programming
Past (10 -15 ) years ago Current

• Monolith Applications
• Microservices Applications

• Deployed in Application Server

• Deployed in Cloud Environments

• Does not embrace distributed • Embrace Distributed Systems

systems
Expectations of the Application

• Response times are expected in milliseconds

• No Downtime is expected

• Scale up automatically based on the load

Restful API using Spring Boot/MVC

Spring MVC
App
Tomcat

Dispatcher
Client Servlet
Controller Service Dao

DB
Thread
pool API Client API
External
Service

• Concurrency is Thread Per Request model

• This style of building APIs are called Blocking APIs

• Wont scale for today’s application needs

Restful API using Spring Boot/MVC

DB
1

Spring MVC App 2 {API}

Embedded Server 3

{API}

Latency = Summation of (DB + API + API) response times

Spring MVC Limitations
• Thread pool size of Embedded tomcat in Spring MVC’s is 200

• Can we increase the thread pool size based on the need ?

• Yes, only to a certain limit.

• Let’s say you have a use case to support 10000 concurrent users.

• Can we create a thread pool of size 10000 Threads ?

• No
Thread and its Limitations
• Thread is an expensive resource

• It can easily take up to 1MB of heap space

• More threads means more memory consumption by the thread itself

• Less heap space for actually processing the request

Restful API using Spring Boot/MVC

Spring MVC
App
Tomcat

Dispatcher
Client Servlet
Controller Service Dao

DB
Thread
pool

Restful API using Spring Boot/MVC

Make these calls in Parallel

DB
1

Spring MVC App 2 {API}

Embedded Server 3

{API}

Latency = Summation of (DB + API + API) response times

Lets explore the asynchrony options in Java

• Callbacks

• Futures
Callbacks
Callbacks
• Asynchronous methods that accept a callback as a parameter and invokes it
when the blocking call completes.

• Writing code with Callbacks are hard to compose and di cult to read and
maintain

• Callbackhell

ffi
Future
 Concurrency APIs in Java
Future CompletableFuture

• Released in Java 5
• Released in Java8

• Write Asynchronous code in a functional

• Write Asynchronous Code
style

• Disadvantages: • Easy to compose/combine MultipleFutures

• No easy way to combine the • Disadvantages:

result from multiple futures

• Future that returns many elements

• Eg., CompletableFuture<List<Result> will need

• Future.get()
to wait for the whole collection to built and
readily available

• This is a blocking call • CompletableFuture does not have a handle for

in nite values

fi
Drawbacks of Spring MVC
• Concurrency is limited in Spring MVC

• Blocking code leads to ine cient usage of threads.

• Servlet API at the server level is a blocking one

ffi
Reactive
Is there a programming
better option to the
available?
rescue
Summary
• Does this mean we should stop using Spring MVC?

• No

• This still works very well for many use cases

What is Reactive Programming ?
What is Reactive Programming ?
• Reactive Programming is a new programming paradigm

• Asynchronous and non blocking

• Data ows as an Event/Message driven stream

fl
Reactive Programming

requestForData( )

request(n)

onNext(1) DB
App onNext(2)
.

.
onNext(n)

onComplete( )

• This is not a blocking call anymore

Push Based data streams model

• Calling thread is released to do useful work
What is Reactive Programming ?
• Reactive Programming is a new programming paradigm

• Asynchronous and non blocking

• Data ows as an Event/Message driven stream

• Functional Style Code

• BackPressure on Data Streams

fl
Backpressure

requestForData( )

request(n)

onNext(1)
DB
App onNext(2)
.

.
onNext(n)

onComplete( )

Overwhelm the app with more data

Backpressure

requestForData( )

request(2 )
DB
App onNext(1)

onNext(2)

cancel( )

Backpressure
 Push-based data flow model
Push-Pull based data flow model
When to use Reactive Programming ?

Use Reactive Programming when there is need to

build and support app that can handle high load
Reactive App Architecture

Make these calls in nonblocking style

DB
1

App 2 {API}

Embedded Server 3

{API}

• Handle request using non blocking style

• Netty is a non blocking Server uses Event Loop Model

• Using Project Reactor for writing non blocking code

• Spring WebFlux uses the Netty and Project Reactor for building non blocking or
reactive APIs
Reactive Streams
Reactive Streams are the foundation
for Reactive programming.
 Reactive Streams
• Reactive Streams Speci cation is created by engineers from multiple
organizations:

• Lightbend

• Net ix

• VmWare (Pivotal)
fl
fi
Reactive Streams Specification
• Reactive Streams Speci cation:

• Publisher

• Subscriber

• Subscription

• Processor
fi
 Publisher
public interface Publisher<T>

public void subscribe(Subscriber<? super T> s) 1

• Publisher represents the DataSource

• Database

• RemoteService etc.,
}

 Subscriber
public interface Subscriber<T>

public void onSubscribe(Subscription s) 1

public void onNext(T t) 2
public void onError(Throwable t) 3
public void onComplete() 4
}

requestForData( )

onNext(1)
DB
App onNext(2)
.

.
onNext(n)

onComplete( )

 Subscription
public interface Subscription

public void request(long n);

public void cancel()

requestForData( )

request(2 )
DB
App onNext(1)

onNext(2)

cancel( )

Subscription is the one which connects the app and datasource

}

Reactive Streams - How it works together ?

Success Scenario

subscribe( this ) 1
DB
onSubscribe( ) 2
Subscription
request( n ) 3

onNext( 1 ) 4
Subscriber Publisher
onNext( 2 ) 4.1

.
4.n
onNext( n )
{API}
onComplete( ) 5
Reactive Streams - How it works together ?

Error/Exception Scenario

subscribe( this ) 1
DB
onSubscribe( ) 2
Subscription

request( n ) 3

Subscriber Publisher

onError( ) 4
{API}

• Exceptions are treated like the data

• The Reactive Stream is dead when an exception is

thrown
 Processor
public interface Processor<T, R> extends Subscriber<T>, Publisher<R>

• Processor extends Subscriber and Publisher

• Processor can behave as a Subscriber and Publisher

• Not really used this on a day to day basis

}

Flow API
• Release as part of Java 9

• This holds the contract for reactive streams

• No implementation of the Reactive Streams is available as part of JRE

 What is a
Nonblocking or Reactive
RestFul API ?

NonBlocking or Reactive RestFul API

• A Non-Blocking or Reactive RestFul API has the behavior of providing end to
end non-blocking communication between the client and service

• Non-Blocking or Reactive == Not Blocking the thread

• Thread involved in handling the httprequest and httpresponse is not blocked

at all

• Spring WebFlux is a module that’s going to help us in achieving the Non-

Blocking or Reactive behavior
NonBlocking or Reactive API using Spring WebFlux

Spring WebFlux Project Reactor

App 2
1

Dao

Client Netty Controller Service

APIClient {API}

 Options for
Reactive RestFul API
Using
Spring WebFlux

Setting up the Project

For this
Course

Section Overview
Section Overview

• Explore Project Reactor

•
Spring WebFlux

Spring WebFlux

Annotated Functional
Controllers Endpoints
What are we going to build in this
course ?
Movies Application using MicroServices Pattern
Annotated Controller

MoviesInfo Name, cast,

year
Service
Annotated Controller

MoviesService Functional Endpoints

MoviesReview Rating, Review

Service

Movies Application using MicroServices Pattern

Annotated Controller

MoviesInfo
Service
Annotated Controller

MoviesService Functional Endpoints

MoviesReview
Service

 Streaming Endpoint
Using
Spring Webflux

Streaming Endpoint
• Streaming Endpoint is a kind of Endpoint which continuously sends updates
to the clients as the new data arrives

• This concept is similar to Server Sent Events(SSE)

• Easy to implement in Spring WebFlux

• Examples : Stock Tickers, Realtime updates of Sports Events

Automated Testing
Using JUnit5

Automated Tests
• Automated Tests plays a vital role in delivering quality Software

• Two types of Automated Tests:

• Integration Tests

• Unit Tests
Integration Tests
• Integration test is a kind of test which actually test the application end
to end

1 2 3

Integration
Controller Service Repository DB
Test
Unit Tests
• Unit test is a kind of test which tests only the class and method of interest
and mocks the next layer of the code

Unit Test Controller Service Mock Repository DB

Movies Application using MicroServices Pattern
Annotated Controller

MoviesInfo
Service
Annotated Controller

MoviesService Functional Endpoints

MoviesReview
Service

 Integration Tests using Embedded MongoDB

Integration In-Memory
Controller Service Repository DB
Mongo
Test DB

testImplementation 'de.flapdoodle.embed:de.flapdoodle.embed.mongo

'

Unit Tests
• Unit test is a kind of test which tests only the class and method of interest
and mocks the next layer of the code

Controller Service Repository DB

Unit Test Controller Mock

Mockito
Benefits of Unit Tests
• Unit Tests are faster compared to Integration Tests

• Unit Tests are handy for performing Bean Validations

 Spring WebFlux Test has an
annotation named “@WebFlux” test
 Using ResponseEntity
In
Spring WebFlux

 How Netty Works

with
Spring WebFlux ?

NonBlocking or Reactive API using Spring WebFlux

Spring WebFlux
App 2
1

Dao

Client Netty Controller Service

APIClient {API}

 How does
Netty
handle the request?

Netty (WebFlux’s Default Server)

Spring WebFlux App

Channel

Client

Netty

• Channel represents an open connection

between the client and server

• Request and Response is sent via the

channel
Channel

• Channel has ChannelHandlers

• Accepting the client connection

• Reading the data as bytes from the network to a Java

Object(Transformation)

• Writing the data back to the client

• This is all taken care for us by Spring WebFlux

• As a developer, we just focus on writing the application related code

Channel and EventLoop
• Netty , uses EventLoop model to handle the connections in a nonblocking fashion

• An EventLoop is powered by one single thread

• NodeJs uses the same pattern.

• Node js has just one thread/one eventloop to handle client requests

• Number of Eventloops to handle the request is equal to no of cores in your machine

• Eventloops are part of the EventLoopGroup

EventLoop

Req1
Req2

Event Queue Loop

How Channel and EventLoop linked ?
• Any time a channel is created it gets assigned to an EventLoop

• This EventLoop is responsible for handling the di erent events that occurs in

the lifetime of a channel

ff
Channel Lifecycle

1 ChannelUnregistered Channel is Created and its not registered with the Eventloop

2 ChannelRegistered Channel is registered with the Eventloop

3 ChannelActive Channel is active and its now possible to send and receive the data

4 ChannelInActive Channel is not connected to the client anymore and ready to be closed

All these Lifecycle changes are treated as events

How Netty handles the request ?
• Netty had two EventloopGroups

• One to just accept connections

Spring WebFlux App

• Other one to handle them Controller Service Dao

Client Netty

Req1 Thread1

Response

Event Queue Loop

Netty in Action
 Functional Web
In
Spring WebFlux

Functional Web
• This is an alternative programming model for building RESTFUL APIs in
Spring WebFlux

• Functional web module uses the functional programming aspects:

• Lambdas

• Method References

• Functional Interfaces
Functional Web

Code to handle the request

Rest Endpoints are con gured
is located

Router Handler
fi

Is there an advantage in building

RestFul APIs using Functional Web?
 Functional Web
• Bene ts:

• All the RestFul APIs endpoints are con gured in one single le

• Code is lightweight compared to the Controller alternative

• Challenges:

• Need to have knowledge about functional programming

• Bean Validation is di erent in Functional Web

• Exception handling in Functional Web is di erent from the Controller approach

fi
ff
fi
ff
fi
Movies Application using MicroServices Pattern
Annotated Controller

MoviesInfo
Service
Annotated Controller

MoviesService Functional Endpoints

MovieReview
Service

Movies Application using MicroServices Pattern

Annotated Controller

MoviesInfo
Service
Annotated Controller

MoviesService Functional Endpoints

MovieReview
WebClient Service

Webclient
WebClient
• It is a reactive non-blocking Rest Client

• It uses a functional style API

• It allows the application to interact with other services in a non-blocking

fashion

• Its auto con gured in to the application by Spring Boot

fi
 Exceptions
in
Service to Service
Communication

Movies Application using MicroServices Pattern

MoviesInfo
Service

MoviesService

MovieReview
Service

Http Failures
• Http Failure falls in to two categories:

• 4xx - Client Error

• 400(Bad Request), 404 (Not Found) and etc.,

• 5xx - Server Error

• 500(Internal Server Error), 503 (Service Unavailable) and etc.,

Introduction to Wiremock
Movies Application using MicroServices Pattern

MoviesInfo
Service

MoviesService

MovieReview
Service

 Movies Application using MicroServices Pattern

Mock
MoviesInfo
MoviesInfo
Service
Service

MoviesService

Mock
MoviesReview
MovieReview
Service
Service

Wiremock to the Rescue

Benefits of WireMock
• Easy to test the success scenarios (2xx)

• Test the contract

• Serialization/Deserialization

• Easy to simulate error scenarios

• 4xx

• 5xx

• SocketTimeout Exceptions and more..,

Why Retry failed HTTP calls ?
Movies Application using MicroServices Pattern

MoviesInfo
Service

MoviesService

MovieReview
Service

• Intermittent Network Issues

• Slow Network

• External Service is down

Handle Network Errors

• Retrying Failed Calls

• Retry the failed call N number of times before giving up

• Retry the failed call with a backo

• Retry Speci c Exceptions

• Retry only 5xx not 4xx exceptions

fi
ff
Server Sent Events (SSE)
 Sever Sent Events

Server
Client
(API)

• Uber App - Realtime updates

of the driver location
• Data is sent in the form of events

• Dominos, DoorDash etc.

• Its Unidirectional once the connection is
established between the client and server

• Long live client connections

Publish new MovieInfo as a

ServerSentEvent(SSE)
Sinks