Reactive Card Magic: Understanding Spring WebFlux and Project Reactor

Reactive Card Magic
@JavaFXpert
Web on Reactive Stack with Spring

About Presenter James Weaver
@JavaFXpert
Developer Advocate and International Speaker for Pivotal

Reactive Card Magic
What will we cover?
• Spring WebFlux (what, why, etc.)
• Reactive systems and Reactive programming
• Reactive programming in Java
• Project Reactor
• WebClient reactive client
• Code and concepts walkthrough of Reactive Card Magic application
@JavaFXpert

Spring WebFlux
What is it?
@JavaFXpert
A non-blocking, reactive web framework that
supports Reactive Streams back pressure, and
runs on servers such as Netty, Undertow, and
Servlet 3.1+ containers.
See: Web on Reactive Stack by the Spring team

WebFlux
Like WebMVC but Reactive
@JavaFXpert

Spring WebFlux
Why was it created?
• Because of mobile devices, IoT, and our continuing trend to live online,
some apps today have millions of clients.
• Many apps have Black Friday* style usage patterns, where demand can
spike exponentially.
• Factors such as these drive the need for a non-blocking web stack that:
• handles concurrency with a small number of threads and
• scales with less hardware resources.
@JavaFXpert
* Referring to the busiest shopping day of the year in the US, not the last Friday before Christmas in the UK :-)

Spring WebFlux
Other reasons for creating it
• Continuation style APIs enabled by Java 8 lambda
expressions allow declarative composition of
asynchronous logic
• Lambdas also enabled Spring WebFlux to offer
functional web endpoints alongside with annotated
controllers
@JavaFXpert

Spring WebFlux
What does reactive mean?
• Reactive refers to programming models (and systems) that
are built around asynchronously reacting to external changes
(such as messages and events)
• An important mechanism in reactive is non-blocking back
pressure (ﬂow control) *
@JavaFXpert
See: Web on Reactive Stack by the Spring team
* In synchronous, imperative code, blocking calls serve as a
natural form of back pressure that forces the caller to wait.

reactivemanifesto.org
The Reactive Manifesto
@JavaFXpert

Reactive systems vs. Reactive programming
• Reactive systems represent an architectural style
that allows multiple individual applications to coalesce
as a single unit, reacting to its surroundings, while
remaining aware of each other
• Reactive programming is a subset of asynchronous
programming and a paradigm where the availability of
new information drives the logic forward rather than
having control ﬂow driven by a thread-of-execution
@JavaFXpert
From Reactive programming vs. Reactive systems by Jonas Bonér and Viktor Klang

Some Reactive programming use cases
• External Service Calls
• Highly Concurrent Message Consumers
• Spreadsheets
• Abstraction Over (A)synchronous Processing
@JavaFXpert
From: Notes on Reactive Programming Part I: The Reactive Landscape by Dave Syer

Reactive Programming in Java
A brief and incomplete history
• Reactive programming ideas have been around for a while, appearing
in programming languages (e.g. Erlang) and libraries (e.g. Reactive
Extensions for .NET)
• The open source RxJava (Reactive Extensions for Java) project
helped move reactive programming forward on the Java platform.
• The Reactive Streams initiative provided a standard and speciﬁcation
for compatibility among reactive implementations in Java. This
initiative is a collaboration between engineers from Kaazing,
Lightbend, Netﬂix, Pivotal, Red Hat, Twitter and others.
@JavaFXpert

Reactive Programming in Java
• Reactive Streams
• RxJava
• Reactor
• Spring Framework 5
• Ratpack
• Akka
• Vert.x
@JavaFXpert
From: Notes on Reactive Programming Part I: The Reactive Landscape by Dave Syer

Reactive Streams:
@JavaFXpert
github.com/reactive-streams/reactive-streams-jvm
Is a standard and speciﬁcation for stream-oriented libraries
that:
• process a potentially unbounded number of elements
• sequentially,
• with the ability to asynchronously pass elements between
components,
• with mandatory non-blocking backpressure.
reactive-streams.org

public interface Subscriber<T> {
public void onSubscribe(Subscription s);
public void onNext(T t);
public void onError(Throwable t);
public void onComplete();
}
public interface Subscriber<T> {
public void onSubscribe(Subscription s);
public void onNext(T t);
public void onError(Throwable t);
public void onComplete();
}
Reactive Streams API for Java
@JavaFXpert
enables interoperability between different Reactive implementations
public interface Publisher<T> {
public void subscribe(Subscriber<? super T> s);
}
public interface Subscription {
public void request(long n);
public void cancel();
}
public interface Processor<T, R>
extends Subscriber<T>, Publisher<R> {
}
Adopted by Java 9 in the Flow class

Reactive Streams with Spring
@JavaFXpert
From: Servlet and Reactive Stacks in Spring Framework 5 by Rossen Stoyanchev
Streaming to database with non-blocking back pressure
JSON stream

Reactive Streams with Spring
@JavaFXpert
From: Servlet and Reactive Stacks in Spring Framework 5 by Rossen Stoyanchev
Streaming from database with non-blocking back pressure
JSON stream

23
Project Reactor
The reactive library of choice for Spring WebFlux

Project Reactor
Avoiding callback hell and other asynchronous pitfalls
Reactive libraries such as Reactor aim to address drawbacks of "classic"
asynchronous approaches on the JVM while also focusing on additional aspects:
• Composability and readability
• Data as a ﬂow manipulated with a rich vocabulary of operators
• Nothing happens until you subscribe
• Backpressure or the ability for the consumer to signal the producer that the
rate of emission is too high
• High level but high value abstraction that is concurrency-agnostic
@JavaFXpertSee: From Imperative to Reactive Programming in Project Reactor Guide

abstract class Flux<T>
implements Publisher<T> {
...
}
abstract class Flux<T>
...
}
Reactive Types

abstract class Mono<T>
...
}
abstract class Mono<T>
...
}
Reactive Types

Reactive Types
•Mono<T>
•Flux<T>

Flux.just("Hello", "Reactor", "World")
.subscribe(s -> System.out.println(s));
@JavaFXpert
Hello
Reactor
World
Project Reactor
Simple example

Project Reactor
Marble diagram: Mono
@JavaFXpert

Project Reactor
Marble diagram: Flux
@JavaFXpert

Reactive Card Magic: Understanding Spring WebFlux and Project Reactor

Reactive Marbles
rxmarbles.com
37

App we’ll use for code examples
@JavaFXpert

@JavaFXpert
CardDeck
Repository
Hand
Frequency
Respository
Card Deck
Service
Card
Shufﬂing
Service
Proxy
Poker
Service
Card
Deck
Controller
Poker
Controller
Poker
Service
Card Deck
Data Loader
WebClient
Mono<CardHand> Flux<HandFrequency>
Flux<Card>Mono<String>
Flux<HandFrequency>
Flux<Card>Flux<Card>
Reactive Card Magic
Application Architecture

Getting a New Deck
@JavaFXpert

@RestController
@RequestMapping("/cards/deck")
public class CardDeckController {
private final CardDeckService cardDeckService;
@Autowired
public CardDeckController(
CardDeckService cardDeckService) {
this.cardDeckService = cardDeckService;
}
@GetMapping("/new")
public Mono<CardHand> getCardDeck(@RequestParam(defaultValue = "52")
int numcards) {
return cardDeckService.generate()
.take(numcards)
.collectList()
.map(l -> new CardHand(l, "New Deck"));
}
}
@JavaFXpert
Annotated controller example

@RestController
@RequestMapping("/cards/deck")
public class CardDeckController {
private final CardDeckService cardDeckService;
@Autowired
public CardDeckController(
CardDeckService cardDeckService) {
this.cardDeckService = cardDeckService;
}
@GetMapping("/new")
public Mono<CardHand> getCardDeck(@RequestParam(defaultValue = "52")
int numcards) {
.take(numcards)
.collectList()
.map(l -> new CardHand(l, "New Deck"));
}
}
Annotated controller example
@JavaFXpert

@Bean
RouterFunction<ServerResponse> newDeckRoutes(CardDeckService cds) {
int defaultNumCards = 52;
return RouterFunctions.route(
RequestPredicates.GET("/newdeck"),
request -> cds.generate()
.take(request.queryParam("numcards")
.map(Integer::parseInt).orElse(defaultNumCards))
.collectList()
.map(l -> new CardHand(l,"New Deck"))
.flatMap(ServerResponse.ok()::syncBody));
}
Functional endpoint example
@JavaFXpert

Spring WebFlux
Using WebClient
WebClient is a reactive, non-blocking client for HTTP requests with a
functional-style API client and Reactive Streams support. By comparison to
the RestTemplate, WebClient is:
• non-blocking, reactive, and supports higher concurrency with less
hardware resources.
• provides a functional API that takes advantage of Java 8 lambdas.
• supports both synchronous and asynchronous scenarios.
• supports streaming up or down from a server.
@JavaFXpertFrom Web on Reactive Stack - WebClient

Identifying a Poker hand
@JavaFXpert

WebClient pokerWebClient = WebClient.create("http://127.0.0.1:8080");
Mono<String> pokerHandMono = pokerWebClient.post()
.uri("/poker/idhand")
.body(cardFlux, Card.class)
.retrieve()
.bodyToMono(String.class);
WebClient example
@JavaFXpert
Calling an endpoint to identify a Poker hand

Using Reactor operators
examples from the Reactive Card Magic application
@JavaFXpert
Mono
defaultIfEmpty()
flatMap()
flatMapMany()
map()
retryWhen()
then()
timeout()
Flux
as() flatMapIterable() sort()
collectList() fromArray() subscribe()
compose() fromStream() subscribeOn()
concatWith() index() take()
defer() just() transform()
distinct() map() zip()
filter() range()
flatMap() skip()

Dealing ten cards of same suit
@JavaFXpert

@GetMapping("/{suit}")
public Mono<CardHand> getCardDeckBySuit(
@PathVariable String suit,
@RequestParam(defaultValue = "10") int numcards
) {
.filter(card -> card.getSuit()
.equalsIgnoreCase(suit))
.take(numcards)
.collectList()
.map(l -> new CardHand(l, "Only " + suit));
}
@JavaFXpert
Dealing ten cards of same suit
Examining filter(), take(), collectList() and map() operators

Flux filter operator
public final Flux<T> filter(Predicate<? super T> p)
@JavaFXpert
API documentation

Flux take operator
public ﬁnal Flux<T> take(long n)
@JavaFXpert
API documentation

Flux collectList operator
public ﬁnal Mono<List<T>> collectList()
@JavaFXpert
API documentation

Mono map operator
public ﬁnal <R> Mono<R> map(Function<? super T,? extends R> mapper)
@JavaFXpert
API documentation

Flux<Card>
filter( card -> )
take( 10 )
Flux<Card>
Flux<Card>
collectList()
Mono<List<Card>>
map( list -> new CardHand(list, “Only s“))
Mono<CardHand>
Only
Hearts
take( 9 )take( 8 )take( 7 )take( 6 )take( 5 )take( 4 )take( 3 )take( 2 )take( 1 )take( 0 )

Deal Poker hand: Alternating
@JavaFXpert

private static final Comparator<Card> worthComparator =
Comparator.comparingInt(Card::getWorth);
public Flux<Card> dealPokerHand(Flux<Card> cardFlux) {
return cardFlux.index()
.take(9)
.filter(t -> t.getT1() % 2 == 0)
.map(Tuple2::getT2) // (t -> t.getT2())
.sort(worthComparator);
}
@JavaFXpert
Examining index() and sort() operators
Deal Poker hand: Alternating

Flux index operator
public ﬁnal Flux<Tuple2<Long,T>> index()
@JavaFXpertAPI documentation

Flux index operator and Tuple2
Flux<Tuple2<Long,Card>>
@JavaFXpertTuple2 API documentation
1
0
2
3
index value

Flux sort operator
public ﬁnal Flux<T> sort(Comparator<? super T> sortFunction)
@JavaFXpertAPI documentation

take( 9 )take( 8 )take( 7 )take( 6 )take( 5 )take( 4 )take( 3 )take( 2 )take( 1 )take( 0 )
Flux<Card>
index()
Flux<Tuple2<Long,Card>>
filter( t -> t.getT1() % 2 == 0 )
map( Tuple2::getT2 )
1 2 3 4 5 6 7 8
0 1 2 3 4 5 6 7 8Flux<Tuple2<Long,Card>>
Flux<Tuple2<Long,Card>> 0 2 4 6 8
Flux<Card>
Flux<Card>
sort(worthComparator)
0
take( 9 )

Reactive Card Magic
If we have time, walk through more code including:
• Additional shuffling operations such as Riffle Shuffle
• Populating the Card Deck repository
• The /shuffledealrepeat endpoint
• The /handfrequencies endpoint
• Testing with StepVerifier
@JavaFXpert

Spring WebFlux
Spring MVC and/or WebFlux?
@JavaFXpertFrom Web on Reactive Stack - Applicability

Reactive Card Magic
What have we covered? Any more questions?
• Spring WebFlux (what, why, etc.)
• Reactive systems and Reactive programming
• Reactive programming in Java
• Project Reactor
• WebClient reactive client
• Code and concepts walkthrough of Reactive Card Magic application
@JavaFXpert

Web resources
• Spring Framework 5 Web on Reactive Stack: 
docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#spring-webﬂux
• Project Reactor: 
projectreactor.io
• The Reactive Manifesto: 
reactivemanifesto.org
• Reactive Card Magic app: 
github.com/JavaFXpert/card-deck-demo
• James Weaver’s blogs:
• JavaFXpert.com
• CulturedEar.com
@JavaFXpert

Reactive Card Magic: Understanding Spring WebFlux and Project Reactor

Recommended

More Related Content

What's hot (20)

Similar to Reactive Card Magic: Understanding Spring WebFlux and Project Reactor (20)

More from VMware Tanzu (20)

Recently uploaded (20)

Reactive Card Magic: Understanding Spring WebFlux and Project Reactor