What’s expected in Spring 5

Copyright 2017 Trainologic Ltd.
What’s New in Spring 5.0
What’s New In
Spring 5.0

2 Copyright 2017 Trainologic Ltd.
• Overview
• Programming Paradigms
• Reactive Programming Primer
• Reactive Java Landscape
• Reactive Programming & Spring 5
• WebFlux Framework
What’s New In Spring 5.0

• Current Version is 4.3.9
• Snapshot: 5.0.0 RC2
• Pending 5.0 GA – 27.07.2017
Spring Release
5.0 GA
Jul 2017
1.0 2.0 2.5 3.0 3.1 4.0 4.2 4.3
2004 2006 2007 2009 2011 2013 2015 2016

• Requirements: JDK 8 + Java EE 7
• Based on Java 8: lambda expressions, inferred generics
(java.util.Optional, java.util.function, java.util.stream)
• JEE7: Servlet 3.1, Bean Validation 1.1, JPA 2.1, JMS 2.0
• Compatibility with JDK 9
• Modularization meta-data
• Compitability with JEE8
• Servlet 4.0, Bean Validation 2.0, JPA 2.2, JSON Binding API 1.0
• Reactive Programming Model
• Spring WebFlux (alt. to spring-webmvc)
• Kotlin 1.1 Support
• JUnit 5
Features

• Statically-typed programming language
• Runs on the JVM
• Can be compiled to JavaScript source code
• Interoperates with Java code
• Reliant on classes from JDK
• “Designed to be an industrial-strength object-oriented
language… a ‘better language’ than Java”, Andrey Breslav, Dev. Lead
• Designed by JetBrains (intelliJ)
Kotlin
fun main(args : Array<String>) {
val scope = "world“
println("Hello, $scope!")
}

• Overview

Programming Paradigms
Imperative Programming

•A program consists of a sequence of instructions
•Each of these instructions is executed in the same
order in which you write them
•The execution leads to changes in the state of the
program
•Focuses on describing how a program operates
•e.g.: COBOL, Basic, Smalltalk, C, C++, Perl,
Python, Visual Basic, Visual C++, PHP, Java,
Ruby, VB.NET, C#

Example
List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> output = new ArrayList<>();
for (Integer x : input) {
if (x % 2 == 0) {
output.add(x);
}
}
1. Define and create an input list
2. Define and create an empty output list
3. Take each item of the input list
4. If the item is even, add it to the output list
5. Continue with the following item until the end of the input
list is reached

Functional Programming

• A declarative programming paradigm (what not how)
• Output value of a function depends only on
arguments passed to the function
• Functions do not change the internal program state
• Immutable Data, Concurrency, Lazy Evaluation
• Pure functional: Haskel, Mercury
• Impure: Lisp, Scheme, Closure, Erlang
var output = input.where( x -> x % 2 == 0);

• Java is an imperative programming language.
• Java 8 introduced constructs of functional
programming:
• Lambda Expressions
• Streams
• External libraries adds concepts of functional
programming to Java 6, 7 (e.g. RxJava )
Java?

• An anonymous function that can be passed as an
argument to a method or stored in a variable (no
boiler plate code)
• Enables to “pass around” code (behavior) as data
• Can be used to in place of anonymous inner classes
that implement an interface with just one method -
functional interfaces
• Originates from “lambda calculus”
Lambda Expressions (Java 8)
(parameters) -> {statements;}

Lambda Expressions Example
Runnable noArguments = () -> System.out.println("Hello World");
Runnable noArguments = new Runnable() {
@Override
public void run() {
System.out.println("Hello World");
}
};
noArguments.run();
ActionListener oneArgument = event -> System.out.println("button clicked");
ActionListener oneArgument = new ActionListener() {
@Override public void actionPerformed(ActionEvent e) {
System.out.println("button clicked");
}
};
oneArgument.actionPerformned(new ActionEvent(null, 0, null));
~
~

• Streams are an update to the Java API that lets you
manipulate collections of data in a declarative way
(using a “query” and not imperative statements)
• Can be processed in parallel transparently, without
writing multithreaded code
• Replace “external iteration” with “internal iteration”
Streams

Streams Example
int count = 0;
Iterator<Course> iterator = allCourses.iterator();
while(iterator.hasNext()) {
Course course = iterator.next();
if (course.isAbout(“Spring 5")) {
count++;
}
}
long count = allCourses.stream()
.filter(course -> course.isAbout(“Spring 5"))
.count();
external
iteration
internal
iteration
lazy:
builds up a “Stream recipe”
of how to filter stream
eager:
generate the value
from the stream
lambda expression
“internal iterator”
of stream

• Overview
Reactive Programming Primer

• An asynchronous (non blocking) programming paradigm
• Concerns data streams (transformations)
• Propagates change (event-driven)
Definition

• Based on a model of Publisher and Subscriber
(“Observer Design Pattern”, “GoF” 1994)
• The Publisher publishes a stream of data, to
which the Subscriber is asynchronously
subscribed
• A stream of data is a sequence of data items
occurring over time
Publisher / Subscriber

• Processors (“Operations”) are higher order functions
that operate on the stream (“transform”)
• can be chained
• sit between the Publisher and Subscriber
• transform one stream of data to another
• Publisher and the Subscriber are independent of
the transformation
• Expressed declaratively (!imperatively)
Operations

• A combination of the Observer pattern, the Iterator
pattern, and functional programming
• The Iterator is a pull model, the application pulls
items from the source (Iterator.next())
• The Observer is a push model, the items from the
source are pushed to the application (update())
• The subscriber requests (pulls) N items; the Publisher
pushes at most N items to the Subscriber
Observer + Iterator + Functional

• The subscriber can signal the publisher that the rate of
emission is too high for it to keep up
• The publisher can control its pace rather than having to
discarding data, or result in cascading failure
• Handling backpressure:
• Publisher (During Emission): Throttling, Buffering
• Subscriber: ask the publisher to slow down the
emission
Backpressure

• Simpler code, more readable
• No nested callbacks (composition)
• No boilerplate code – focus on BL
• Handles low-level threading, synchronization, and
concurrency issues
• Efficient
• Blocking code is wasteful (the thread sits idle)
• Application threads introduces contention and
concurrency problems
Advantages

• “…to condense the knowledge we accumulated as an
industry about how to design highly scalable and
reliable applications into a set of required architecture
traits, and to define a common vocabulary to enable
communication about these matters between all
participants in that process—developers, architects,
project leaders, engineering management, CTOs.”
• “…a dictionary of best practices…”
Roland Kuhn, Akka Tech Lead at Typesafe, one of the authors of the
manifesto
• http://www.reactivemanifesto.org/
• http://www.reactivemanifesto.org/glossary
Reactive Manifesto

Reactive Systems are:
• Responsive
• provide rapid and consistent response times
• Resilient
• stays responsive in the face of failure (replication,
containment, isolation and delegation)
• Elastic
• stays responsive under varying workload, react to
changes, increase / decrease resources allocated
• Message Driven
• rely on asynchronous message-passing (loose
coupling, isolation, location transparent)

• Overview

ReactiveX
(Reactive Extensions)
http://reactivex.io/
RxJava 1.0.0
(2014) Netflix
RxJava 2.0.0
(2016)
…
Reactive Streams
(Netflix, Pivotal, Typesafe)
http://reactive-streams.org
Rx.Net
• Specification
• API
The Reactive Manifesto
http://reactivemanifesto.org/
JDK 9 API
j.u.c.Flow
(2017)
Project Reactor (Pivotal)
http://projectreactor.io/
Vertx.io (Eclipse)
http://vertx.io/
Spring 5
https://spring.io/
WebFlux
https://spring.io/
Reactive Java Landscape
Reactive Streams
Commons

• Based on a series of blogs by Dávid Karnok (RxJava project
lead + contributor Reactor-Core)
• Reactive libraries and associated concepts evolved over
time.
• Suggests categorization into “generations” (1-4)
Reactive Libraries Generations

• 0th generation
• java.util.Observable API (GoF)
• one stage: publish-subscribe, non-composable
• 1st generation
• Rx.NET (2010), Reactive4Java (2011), RxJava (2013)
• No cancel, Backpressure problem
• 2nd generation
• Subscriber, Producer by RxJava
• Functional transformation

• 3rd generation
• Incompatibility between reactive libraries
• Reactive Streams spec was created
• RxJava 2.0, Project Reactor, Akka Streams
• 4th generation
• RxJava 2.0 rewritten from scratch
• Reactive Streams Commons (RxJava 2.x +
Project Reactor 2.5+)
• Common operators + optimizations

RxJava2
(Java 6)
Reactor 3
(Java 8)
RxJava1
(Java 6)
Reactive
Streams /
Java 9
Java 8Type
Semantic /
Library
Maybe<T>Mono<T>Observable<T>Publisher<T>CompletableFuture<T>0..1 result
Observable<T>
Flowable<T>
Flux<T>Observable<T>Publisher<T>0..N result
Single<T>Mono<T>Sngle<T>Publisher<T>CompletableFuture<T>1 result
CompletableMono<Void>CompletablePublisher<Void>CompletableFuture<Void>No result
Reactive Streams Types

• Based on the Reactive Streams specification –
“standard de facto”
• Provides only the interfaces and no implementations
(expect for SubmissionPublisher)
Java 9 j.u.c.Flow

Java 9 j.u.c.Flow

• Overview

• Spring uses Reactor 3.0 for reactive support
• Reactor is a Reactive library for building non-blocking
applications on the JVM
• Started at 2012 by Pivotal
• Based on the Reactive Streams Specification
• 4rth Generation
• https://projectreactor.io/
• Spring provides the option to use RxJava
implementation
Reactor 3.0
Reactive Programming in Spring 5.0

Modularization
Reactor 3.0
Bridge to RxJava 1/2
Common Operators
Implementation of RS
Inter Process Connections
(decode, send, serve)

• A provider of a potentially unbounded number of
sequenced elements
• Publishes them according to the demand received
from its Subscriber(s)
• Can serve multiple Subscribers subscribed
dynamically over time
Interface org.reactivestreams.Publisher<T>
Reactor 3.0 API
void subscribe(Subscriber<? super T> s)

• Will receive call to onSubscribe(Subscription) once
• No notifications until Subscription.request(long)
• One or more invocations of onNext(Object) up to
the maximum
• Single invocation of onError(Throwable) or
onComplete()
Interface org.reactivestreams.Subscriber<T>
Reactor 3.0 API
void onComplete()
void onError(java.lang.Throwable t)
void onNext(T t)
void onSubscribe(Subscription s)

• Represents a one-to-one lifecycle of a Subscriber
subscribing to a Publisher
• Can only be used once by a single Subscriber
• Used to both signal desire for data and cancel
demand
Interface org.reactivestreams.Subscription
Reactor 3.0 API
void cancel()
void request(long n)

• Transforms sequence of data
• Adds behavior to a Publisher, wraps the previous
step’s Publisher into a new instance.
• Create a chain of operators that originate from the
first Publisher (like an onion)
• Not defined in Reactive Streams spec (*)
• Implemented in: Reactive Streamas Commons
http://github.com/reactor/reactive-streams-commons
Cooperation between Reactor Project + RxJava
Reactive-Streams compliant operators
Operators
Reactor 3.0 API

Flux

• A Reactive Streams (org.reactivestreams) Publisher
• Emits 0 to N elements
• Completes (successfully or with an error)
Flux
Reactor 3.0 API

Mono

• A Reactive Streams (org.reactivestreams) Publisher
• Emits 0 to 1 elements
• Completes successfully by emitting an element, or with
an error
Mono
Reactor 3.0 API

E.g.: Create Flux/Mono
Reactor 3.0 API
Flux<String> seq1 = Flux.just("foo", "bar", "foobar");
List<String> iterable = Arrays.asList("foo", "bar", "foobar");
Flux<String> seq2 = Flux.fromIterable(iterable);
Mono<String> noData = Mono.empty();
Mono<String> data = Mono.just("foo");
Flux<Integer> numbersFromFiveToSeven = Flux.range(5, 3);

E.g.: Chaining Operators 1
Reactor 3.0 API
Flux<String> secrets = Flux .just("foo", "chain")
.map(secret -> secret.replaceAll(".", "*"))
.subscribe(next -> System.out.println("Received: " + next));
Received: ***
Received: *****
http://projectreactor.io/docs/core/release/reference/docs/index.html#_operators

E.g.: Create Flux/Mono
Reactor 3.0 API
List<String> words = Arrays.asList( "the", "quick", "brown",
"fox", "jumped", "over", "the", "lazy", "dog" );

E.g.: Chaining Operators 2
Reactor 3.0 API
Flux<String> manyLetters = Flux
.fromIterable(words)
.flatMap(word -> Flux.fromArray(word.split("")))
.distinct()
.sort()
.zipWith(Flux.range(1, Integer.MAX_VALUE),
(string, count) ->
String.format("%2d. %s", count, string));
manyLetters.subscribe(System.out::println);
1. a
2. b
...
18. r
19. t
20. u
...
25. z
https://www.infoq.com/articles/reactor-by-example
letters stream counter stream

E.g.: Provide Subscriber Impl
Reactor 3.0 API
Flux.just(1, 2, 3, 4)
.log()
.subscribe(new org.reactivestreams.Subscriber<Integer>() {
@Override
public void onSubscribe(org.reactivestreams.Subscription s){
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(Integer integer) {
System.out.println(integer);
}
@Override
public void onError(Throwable t) {
System.out.println("Error: " + t.toString());
}
@Override
public void onComplete() {
System.out.println("Completed");
}
});
http://www.baeldung.com/reactor-core

E.g.: Provide Subscriber Impl
Reactor 3.0 API
??? 25, 2017 11:13:13 PM reactor.util.Loggers$JdkLogger info
INFO: | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)
INFO: | request(unbounded)
INFO: | onNext(1)
1
INFO: | onNext(2)
2
INFO: | onNext(3)
3
INFO: | onNext(4)
4
INFO: | onComplete()
Completed
http://www.baeldung.com/reactor-core

• Cold Sequence
• static, fixed length
• will start anew for each Subscriber
• never start generating until subscription
• Hot Sequence
• late subscribers will receive only the signals
emitted after they subscribed
Hot vs. Cold Sequences

Hot vs. Cold Sequences
UnicastProcessor<String> hotSource = UnicastProcessor.create();
Flux<String> hotFlux = hotSource.publish()
.autoConnect()
.map(String::toUpperCase);
hotFlux.subscribe(d -> System.out.println("Subscriber 1 to Hot Source: "+d));
hotSource.onNext("blue");
hotSource.onNext("green");
hotFlux.subscribe(d -> System.out.println("Subscriber 2 to Hot Source: "+d));
hotSource.onNext("orange");
hotSource.onNext("purple");
hotSource.onComplete();
Subscriber 1 to Hot Source: BLUE
Subscriber 1 to Hot Source: GREEN
Subscriber 1 to Hot Source: ORANGE
Subscriber 2 to Hot Source: ORANGE
Subscriber 1 to Hot Source: PURPLE
Subscriber 2 to Hot Source: PURPLE

• A mechanism to ensure publishers don’t overwhelm
subscribers
• A downstream can tell an upstream to send it fewer
data in order to prevent it from being overwhelmed
Backpressure
Flux<String> source = Flux.just("1","2","3","4","5");
source.log().map(String::toUpperCase).subscribe(new
BaseSubscriber<String>() {
@Override
protected void hookOnSubscribe(Subscription subscription) {
subscription.request(1);
}
@Override
protected void hookOnNext(String value) {
System.out.println("Backpressure: " + value);
subscription.request(1);
}
});

• Overview

• contains support for:
• reactive HTTP
• WebSocket clients
• reactive server web applications
• based on 2 programming models
• Annotation based (@Controller)
• Functional routing and handling (Java 8 lambda)
New spring-webflux module
WebFlux

Server-side stack
WebFlux

• WebFlux can run on
• Servlet 3.1 Non-Blocking IO API Containers
• Async runtimes e.g.: Netty and Undertow
• Body of the request and response exposed as
Flux<DataBuffer> (not InputStream, OutptStream)
• HandlerMapping, HandlerAdapter, are non-blocking
and operate on the reactive ServerHttpRequest and
ServerHttpResponse
Containers
WebFlux

WebFlux
@RestController
public class PersonController {
private final PersonRepository repository;
public PersonController(PersonRepository repository) {
this.repository = repository;
}
@PostMapping("/person")
Mono<Void> create(@RequestBody Publisher<Person> personStream) {
return this.repository.save(personStream).then();
{
@GetMapping("/person")
Flux<Person> list() {
return this.repository.findAll();
}
@GetMapping("/person/{id}")
Mono<Person> findById(@PathVariable String id) {
return this.repository.findOne(id);
}
{

WebFlux
• Immutable interfaces
• Provide access to HTTP messages
• request expose the body as Flux or Mono
• you create a ServerResponse with a builder
• response accepts RS Publisher as body
ServerRequest / ServerResponse
Flux<Person> people = request.bodyToFlux(Person.class);
Flux<Person> people = request.body(BodyExtractors.toFlux(Person.class);
Mono<String> string = request.body(BodyExtractors.toMono(String.class);

• HandlerFunction handles incoming HTTP requests
• takes a ServerRequest
• returns a Mono<ServerResponse>
HandlerFunctions
WebFlux
HandlerFunctionServerRequest Mono<ServerResponse>
HandlerFunction<ServerResponse> helloWorld =
request -> ServerResponse.ok().body(fromObject("Hello World"));

• Handler functions as lambda’s are less readable
• It is recommended to group related handler functions
into a handler or controller class
HandlerFunctions
WebFlux
public class PersonHandler {
public Mono<ServerResponse> listPeople(ServerRequest request) { 1
Flux<Person> people = repository.allPeople();
return ServerResponse.ok()
.contentType(APPLICATION_JSON)
.body(people, Person.class);
}
}

• Receive ServerRequest
• Returns a Mono<HandlerFunction>
• Has a similar purpose as the @RequestMapping
• Can be composed
RouterFunctions
WebFlux
PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);
RouterFunction<ServerResponse> personRoute =
route(GET("/person/{id}").and(accept(APPLICATION_JSON)), handler::getPerson)
.andRoute(GET("/person").and(accept(APPLICATION_JSON)), handler::listPeople)
.andRoute(POST("/person").and(contentType(APPLICATION_JSON)),
handler::createPerson);
exposes a reactive Person repository

Running a router function in a Server
WebFlux
RouterFunction<ServerResponse> route = ...
HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
ReactorHttpHandlerAdapter adapter =
new ReactorHttpHandlerAdapter(httpHandler);
HttpServer server = HttpServer.create(HOST, PORT);
server.newHandler(adapter).block();
RouterFunctions.toHttpHandler(...)RouterFunction HttpHandler

WebFlux
• WebClient - non-blocking and reactive alternative to
the RestTemplate
• Exposes reactive ClientHttpRequest and
ClientHttpResponse
• Body of the request and response is a
Flux<DataBuffer>
Client Side

Client Side
WebFlux
WebClient client = WebClient.create("http://example.com");
Mono<Account> account = client.get()
.url("/accounts/{id}", 1L)
.accept(APPLICATION_JSON)
.exchange()
.then(response -> response.bodyToMono(Account.class));

• http://reactivex.io/
• http://www.reactive-streams.org/
• http://www.reactivemanifesto.org/
• http://projectreactor.io/
• https://community.oracle.com/docs/DOC-1006738
• https://github.com/spring-projects/spring-
framework/wiki/What%27s-New-in-the-Spring-
Framework
WebFlux

What’s expected in Spring 5

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to What’s expected in Spring 5

Similar to What’s expected in Spring 5 (20)

Recently uploaded

Recently uploaded (20)

What’s expected in Spring 5

Editor's Notes