Spring Framework 5.0 and Spring Boot 2.0 contain groundbreaking technologies known as reactive streams, which enable applications to utilize computing resources efficiently.
In this session, James Weaver will discuss the reactive capabilities of Spring, including WebFlux, WebClient, Project Reactor, and functional reactive programming. The session will be centered around a fun demonstration application that illustrates reactive operations in the context of manipulating playing cards.
Presenter : James Weaver, Pivotal
5. 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
6. 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
8. 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 :-)
12. 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
13. 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 (flow 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.
15. 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 flow driven by a thread-of-execution
@JavaFXpert
From Reactive programming vs. Reactive systems by Jonas Bonér and Viktor Klang
16. 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
17. 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 specification
for compatibility among reactive implementations in Java. This
initiative is a collaboration between engineers from Kaazing,
Lightbend, Netflix, Pivotal, Red Hat, Twitter and others.
@JavaFXpert
18. 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
19. Reactive Streams:
@JavaFXpert
github.com/reactive-streams/reactive-streams-jvm
Is a standard and specification 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
20. 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
21. 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
22. 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
24. 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 flow 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
41. @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
42. @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"));
}
}
Annotated controller example
@JavaFXpert
43. @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
44. 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
46. 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
64. 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
66. 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
67. Web resources
• Spring Framework 5 Web on Reactive Stack:
docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#spring-webflux
• 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