"Reactive Programming in Java" at Froscon 2017 by Vadym Kazulkin/Rodion Alukhanov

byVadymKazulkinandRodionAlukhanov, ip.labsGmbH
Reactive Programming in Java

Reactive Programming in Java by Vadym Kazulkin and Rodion Alukhanov, ip.labs GmbH
ip.labsGmbH
●

Agenda
• Reactive Programming in general
• Reactive Streams and JDK 9 Flow API
• RxJava 2
• Spring Reactor 3
• Demo of reactive application with Spring 5, Spring Boot 2, Netty, MongoDB
and Thymeleaf technology stack

Reactive Streams

Subscriber/Publisher

Subscription

Publisher Implementations

RxJava2

public List<Photo> getPhotos() {
List<Photo> result = …
while (...) {
result.add(...);
}
return result;
}
Observable<Photo> publisher = Observable.create(subscriber -> {
while (...) {
Photo photo = ...
subscriber.doNext(photo);
}
subscriber.onCompleted();
});
Classic vs. Reactive (Cold Publisher)
for (Item item : getPhoto()) {
System.out.println(item.toString());
}
publisher.subscribe(item->{
System.out.println(item.toString());
});

RxJava 2 Basics
Observable<Customer> customers = ...
Observable<Customer> adults = customers.filter(c -> c.age > 18);
Observable<Address> addresses = adults.map(c -> c.getDefaultAddress());
Observable<Order> orders = customers.flatMap(c ->
Observable.fromArray(c.getOrders())
);
Observable<Picture> uploadedPhotos = customers.flatMap(c ->
Observable.fromArray(dao.loadPhotosByCustomer(c.getId()))
);

Example. Print Photo Book
Fetch photo IDs from Book
Load meta data from Database (ID, Dimentions, Source etc.)
Load images from server HDD if avaliable
Load images from source (for example Cloud Service)
Validate Image
+
User authentication & authorisation
0 ms
10 x 100ms
90 x 50ms
10 x 500ms
100 x 50ms
max 500ms

Loading Meta Data. Buffer.
Observable<Integer> ids = Observable.fromIterable(book.getPhotoIDs());
Observable<List<Integer>> idBatches = ids.buffer(10);
Observable<MetaData> metadata =
idBatches.flatMap(ids -> metadataDao.loadingMetadata(ids));

Loading Picture from HDD. FlatMap with at most a single result
Observable<PictureFile> fromDisk = ids.flatMap(id -> loadingFromDisk(id));
public Observable<PictureFile> loadingFromDisk(Integer id) {
Observable<PictureFile> result = Observable.create(s -> {
try {
s.onNext(pictureDao.loadFromHdd(id));
} catch (PictureNotFound e) {
System.out.println("Not found on disk " + id);
}
s.onComplete();
}

Loading from Cloud. Filter
Observable<PictureFile> fromCloud =
metadata.filter(m->m.cloud).
flatMap(id -> loadingFromCloud(id.id));
metadata 1
metadata 2
metadata 3
metadata 4
metadata 5
disk-file 1
disk-file 2
disk-file 4
cloud-file 3
cloud-file 5

Merging Cloud and HDD
Observable<PictureFile> allPictures = fromDisk.mergeWith(fromCloud);
metadata 1
metadata 2
metadata 3
metadata 4
metadata 5
disk-file 1
cloud-file 3
disk-file 2
disk-file 4
cloud-file 5

Joining Metadata with Picture Files
Observable<Pair<MetaData, PictureFile>> pairs =
metadata.join(allPictures, (m)->lastMeta, (f)->lastFile, Pair::of);
metadata 1 + disk-file 1
metadata 3 + cloud-file 3
pairs = pairs.filter(p->p.fst.id == p.snd.id)

Observable<Picture> pictures =
pairs.filter(p->p.fst.id == p.snd.id).map(p->new Picture(p.snd,
p.fst));
Joining Metadata with Picture Files

Validating Result
Observable<Picture> validated = pictures.flatMap(p-
>validation(p));

Adding Authentication
Observable<Boolean> auth = auth();
Observable<Pair<Boolean, Picture>> result =
Observable.combineLatest(auth, validated, Pair::of);

Back in the Real World
BlockingObservableNext<Pair<Boolean, Picture>> b =
new BlockingObservableNext<>(result);
for (Pair<Boolean, Picture> item : b) {
System.out.println("Finished " + item.snd.id);
}

Compare Results
Observable<Integer> ids = loadingIds();
Observable<MetaData> metadata = ids.buffer(10).flatMap(id -> loadingMetadata(id));
Observable<PictureFile> fromDisk = ids.flatMap(id -> loadingFromDisk(id));
Observable<PictureFile> fromCloud = metadata.filter(m->m.cloud).flatMap(id ->
loadingFromCloud(id.id));
Observable<PictureFile> allPictures = fromDisk.mergeWith(fromCloud);
ObservableSource<MetaData> lastMeta = (l) -> metadata.takeLast(1);
ObservableSource<PictureFile> lastFile = (l) -> allPictures.takeLast(1);
Observable<Pair<MetaData, PictureFile>> pairs = metadata.join(allPictures, (m)->lastMeta, (f)-
>lastFile, Pair::of);
Observable<Picture> pictures = pairs.filter(p->p.fst.id == p.snd.id).map(p->new Picture(p.snd, p.fst));
Observable<Picture> validated = pictures.flatMap(p->validation(p));
Observable<Boolean> auth = auth();
Classic -> 20 sec
Reactor -> 1 sec

SpringReactor 3

SpringReactor Timeline
●

SpringReactor 3BigPicture

ReactiveStreamInterfaces

Spring Reactor 3 Main Types
Flux implements Publisher
is capable of emitting of 0 or more items

Spring Reactor 3 Main Types
Mono implements Publisher
can emit at most once item

Spring Reactor 3 Examples
Publisher creation
Flux<String> productTitles = Flux.just("Print 9x13", "Photobook A4", "Calendar A4");
Mono<String> productTitles = Mono.just("Print 9x13");
Flux<String> productTitles = Flux.fromIterable(Arrays.asList("Print 9x13",
"Photobook A4", "Calendar A4"));
Flux<String> productTitles = Flux.fromArray(new String[]{"Print 9x13",
"Photobook A4", "Calendar A4"});
Flux<String> productTitles = Flux.fromStream(Stream.of("Print 9x13",
"Photobook A4", "Calendar A4“));
Mono.fromCallable(), Mono.fromRunnable(), Mono.fromFuture()
Flux.empty(), Mono.empty(), Flux.error(), Mono.error()

Event subscription
productTitles.subscribe(System.out::println);
Output:
Print 9x13
Photobook A4
Calendar A4

Logging
productTitles.log().subscribe(System.out::println);
Output:
INFO reactor.Flux.Array.2 - | onSubscribe()
INFO reactor.Flux.Array.2 - | request(unbounded)
INFO reactor.Flux.Array.2 - | onNext(Print 9x13)
Print 9x13
INFO reactor.Flux.Array.2 - | onNext(Photobook A4)
Photobook A4
INFO reactor.Flux.Array.2 - | onNext(Calendar A4)
Calendar A4
INFO reactor.Flux.Array.2 - | onComplete()

Event subscription with own Subscriber
productTitles.subscribe(new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(String t) {
System.out.println(t);
}
@Override
public void onError(Throwable t) {
}
@Override
public void onComplete() {
}
});

Event subscription with custom Subscriber with back-pressure
productTitles.subscribe(new Subscriber<String>() {
private long count = 0;
private Subscription subscription;
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
subscription.request(2);
}
public void onNext(String t) {
count++;
if (count>=2) {
count = 0;
subscription.request(2);
}
}
...

Event subscription with custom Subscriber with back-pressure
productTitles.log().subscribe(new Subscriber<String>()
{subscription.request(2);..}
Output:
INFO reactor.Flux.Array.2 - | onSubscribe()
INFO reactor.Flux.Array.2 - | request(2)
INFO reactor.Flux.Array.2 - | onNext(Print 9x13)
Print 9x13
INFO reactor.Flux.Array.2 - | onNext(Photobook A4)
Photobook A4
INFO reactor.Flux.Array.2 - | request(2)
INFO reactor.Flux.Array.2 - | onNext(Calendar A4)
Calendar A4
INFO reactor.Flux.Array.2 - | onComplete()

Spring Reactor 3 Operations
Transforming (map, scan)
Combining (merge, startWith)
Filtering (last, skip)
Mathematical (count, average, max)
Boolean (every, some, includes)
Source: http://rxmarbles.com

Elements filtering
Flux<String> productTitlesStartingWithP =
productTitles.filter(productTitle-> productTitle.startsWith("P"));
productTitlesStartingWithP.subscribe(System.out::println);
Output:
Print 9x13
Photobook A4

Elements counter
Mono<Long> productTitlesCount = productTitles.count();
productTitlesCount.subscribe(System.out::println);
Output:
3

Check if all elements match a condition
Mono<Boolean> allProductTitlesLengthBiggerThan5=
productTitles.all(productTitle-> productTitle.length() > 5);
allProductTitlesLengthBiggerThan5.subscribe(System.out::println);
Output:
true

Element mapping
Flux<Integer> productTitlesLength =
productTitles.map(productTitle-> productTitle.length()) ;
productTitlesLength.subscribe(System.out::println);
Output:
10
12
11

Concatenation of 2 Publishers
Mono<String> anotherProductTitle=Mono.just("Teddy");
Flux<String> concatProductTitles =
productTitles.concatWith(anotherProductTitle);
concatProductTitles.subscribe(System.out::println);
Output:
Print 9x13
Photobook A4
Calendar A4
Teddy

Zipping of 2 Publishers
Flux<Double> productPrices = Flux.fromIterable(Arrays.asList(0.09, 29.99, 15.99));
Flux<Tuple2<String, Double>> zippedFlux = Flux.zip(productTitles,
productPrices);
zippedFlux.subscribe(System.out::println);
Output:
[Print 9x13,0.09]
[Photobook A4,29.99]
[Calendar A4,15.99]

Parallel processing
Flux<Double> productPrices = Flux.fromIterable(Arrays.asList(0.09, 29.99, 15.99));
Flux.zip(productTitles, productPrices)
.parallel() //returns ParallelFlux, uses all available CPUs or call
parallel(numberOfCPUs)
.runOn(Schedulers.parallel())
.sequential()
.subscribe(System.out::println);
Output:
[Print 9x13,0.09]
[Photobook A4,29.99]
[Calendar A4,15.99]

Blocking Publisher
BlockingFlux:
Iterable<String> blockingConcatProductTitles =
productTitles.concatWith(anotherProductTitle) .toIterable();
or
Stream<String> blockingConcatProductTitles =
productTitles.concatWith(anotherProductTitle) .toStream();
BlockingMono:
String blockingProductTitles = Mono.just("Print 9x13") .block();
or
CompletableFuture blockingProductTitles = Mono.just("Print 9x13").toFuture();

LMAX Disruptor
RingBuffer withmultipleproducersandconsumers
Source: https://github.com/LMAX-Exchange/disruptor/wiki/Introduction

Test the publishers
Duration verificationDuration = StepVerifier.create(productTitles).
expectNextMatches(productTitle -> productTitle.equals("Print 9x13")).
expectNextMatches(productTitle -> productTitle.equals("Photobook A4")).
expectNextMatches(productTitle -> productTitle.equals("Calendar A4")).
expectComplete().
verify());

Test the publishers
StepVerifier.create(productTitles).
expectNextMatches(productTitle -> productTitle.equals("Print 9x13")).
expectNextMatches(productTitle -> productTitle.equals("Photobook A4")).
expectNextMatches(productTitle -> productTitle.equals("Calendar A4")).
expectComplete().
verify())
Output:
Exception in thread "main" java.lang.AssertionError: expectation
"expectComplete" failed (expected: onComplete(); actual: onNext(Calendar
A4));

SpringReactor Compatibility toJava9FlowAPI

RxJava2vsSpringReactor 3

Comparingreactiveandstreamingimplementations
Source: http://akarnokd.blogspot.de/2016/12/the-reactive-scrabble-benchmarks.html
Source: https://twitter.com/akarnokd/status/808995627237601280

Thefutureof ReactiveStreamAPIs
4th generation already
5th generation will heavily make use of advanced „operator
fusion“
Source http://akarnokd.blogspot.de/2016/03/operator-fusion-part-1.html

Spring 5 / Spring Boot 2 / Netty /
MongoDB / Thymeleaf
Demo

Spring5/ SpringWebReactive

Dependencies

Non-blockingNettyWebClient

MongoDB ReactiveDatabaseTemplate

Model

Repository

Thymeleaf ReactiveView Resolver

Controller

View

Non-blockingJSON ParsingwithJackson

Testing

Benefits of the Reactive Applications
• Efficient resource utilization (spending less money on
servers and data centres)
• Processing higher loads with fewer threads
Source: https://spring.io/blog/2016/06/07/notes-on-reactive-programming-part-i-the-reactive-landscape

Uses Cases for Reactive Applications
• External service calls
• Highly concurrent message consumers
Source: https://spring.io/blog/2016/06/07/notes-on-reactive-programming-part-i-the-reactive-landscape

Pitfalls of reactive programming
• For the wrong problem, this makes things worse
• Hard to debug (no control over executing thread)
• Mistakenly blocking a single request leads to increased
latency for all requests -> blocking all requests brings a
server to its knees
Source: https://spring.io/blog/2016/07/20/notes-on-reactive-programming-part-iii-a-simple-http-server-application

Questions?

Contact
Vadym Kazulkin :
Email : v.kazulkin@iplabs.de
Xing : https://www.xing.com/profile/Vadym_Kazulkin
Rodion Alukhanov :
Email : r.alukhanov@iplabs.de
Xing : https://www.xing.com/profile/Rodion_Alukhanov

"Reactive Programming in Java" at Froscon 2017 by Vadym Kazulkin/Rodion Alukhanov

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a "Reactive Programming in Java" at Froscon 2017 by Vadym Kazulkin/Rodion Alukhanov

Similar a "Reactive Programming in Java" at Froscon 2017 by Vadym Kazulkin/Rodion Alukhanov (20)

Más de Vadym Kazulkin

Más de Vadym Kazulkin (20)

Último

Último (20)

"Reactive Programming in Java" at Froscon 2017 by Vadym Kazulkin/Rodion Alukhanov