”Everything is a stream“ - This often cited mantra indicates why Reactive Programming is such a powerful tool for handling data flows in almost every part of an application. Reactive Programming has experienced a significant growth in popularity in recent years. But its growing popularity also leads to a Babylonian confusion: the term ”Reactive“ has become overloaded and ”is now being associated with several different things to different people“ (Jonas Bonér, Viktor Klang). To understand what Reactive Programming is - and what it isn’t - this talk surveys the landscape sharpened by trends like Reactive Streams, Reactive Extensions and Reactive Systems. It then summarizes the basic principles of Reactive Programming by looking at the Reactor library and discusses examples, of how to use this library in a legacy system.

1. Declarative Concurrency
with Reactive Programming
Florian Stefan | #ebaytechtalk

2. Who am I?
§ Florian Stefan
§ fstefan@ebay.com | @f_s_t_e_f_a_n
§ Software Engineer at mobile.de (eBay Classifieds Group)
§ JVM-based web applications in cloud environment
Introduction

3. Why am I here?
§ C10K problem in IoT project
§ Spring, Play, Netty, Node.js
§ Legacy Systems / Microservice Architectures
Introduction

4. REACTIVE
Introduction

5. Reactive
Streams
Akka
Streams
ReactorRxJava 2
Back-
pressure
Marble
Diagrams
Function Composition
with Higher Order
Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
Reactive
Extensions
Introduction

6. Reactive
Streams
Akka
Streams
ReactorRxJava 2
Back-
pressure
Marble
Diagrams
Function Composition
with Higher Order
Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive
Extensions
Introduction

7. The Reactive Manifesto
Reactive Systems
responsive
resilient
event-driven
scalable

8. The Reactive Manifesto
Reactive Systems
responsive
resilient
event-driven
scalable
scalable
react to load
responsive
react to user
resilient
react to failure
event-driven
react to events

9. Reactive Programming
Reactive
Streams
Akka
Streams
ReactorRxJava 2
Back-
pressure
Marble
Diagrams
Function Composition
with Higher Order
Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive
Extensions

10. Reactive Extensions
§ Observer Pattern
§ Operators for transforming, composing,
scheduling, error-handling
§ Modeling event-based programs
§ Avoiding global state and side effects
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

11. Marble Diagrams
Reactive Programming
Stream emitting 3 events,
followed by completion.
Stream emitting 3 events,
completed by error.
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

12. Reactor
Reactive Programming
Stream emitting 3 events,
followed by completion.
Flux.create(emitter -> {
emitter.next(1);
emitter.next(2);
emitter.next(3);
emitter.complete();
});
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

13. Reactor
Reactive Programming
Stream emitting 3 events,
followed by completion.
Stream emitting 3 events,
completed by error.
Flux.create(emitter -> {
emitter.next(1);
emitter.next(2);
emitter.next(3);
emitter.complete();
});
Flux.create(emitter -> {
emitter.next(1);
emitter.next(2);
emitter.next(3);
emitter.error(new RuntimeException());
});
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

14. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Reactive Programming

15. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
[main] - Before Flux.create()
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Reactive Programming

16. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Reactive Programming

17. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
Reactive Programming

18. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Reactive Programming

19. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
Reactive Programming

20. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
Reactive Programming

21. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
Reactive Programming

22. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
Reactive Programming

23. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
Reactive Programming

24. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
[main] - subscriber.onComplete()
Reactive Programming

25. Subscribe
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
});
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
[main] - subscriber.onComplete()
[main] - Before Flux.create()
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - emitter.next(1)
[main] - subscriber.onNext(1)
[main] - emitter.complete()
[main] - subscriber.onComplete()
[main] - After Flux.subscribe()
Reactive Programming

26. Factory methods: fromIterable
https://raw.githubusercontent.com/reactor/reactor-core/v3.0.6.RELEASE/src/docs/marble/fromiterable.png
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

27. Factory methods: fromIterable
public <T> Flux<T> fromIterable(Iterable<T> iterable) {
return Flux.create(emitter -> {
Iterator<T> iterator = iterable.iterator();
while (iterator.hasNext()) {
emitter.next(iterator.next());
}
emitter.complete();
});
}
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

28. Factory methods: fromIterable
public <T> Flux<T> fromIterable(Iterable<T> iterable) {
return Flux.create(emitter -> {
Iterator<T> iterator = iterable.iterator();
while (iterator.hasNext()) {
emitter.next(iterator.next());
}
emitter.complete();
});
}
naive implementation
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

29. Factory methods: fromCallable
https://raw.githubusercontent.com/reactor/reactor-core/v3.0.6.RELEASE/src/docs/marble/fromcallable.png
Mono<User> maybeUser = Mono
.fromCallable(() -> loadUser(cwid))
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

30. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

31. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)

32. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectSubscription()

33. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectNext(cwids.get(0))
.expectSubscription()

34. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectNext(cwids.get(0))
.expectNext(cwids.get(1))
.expectSubscription()

35. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectNext(cwids.get(0))
.expectNext(cwids.get(1))
.expectNext(cwids.get(2), cwids.get(3), cwids.get(4))
.expectSubscription()

36. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectNext(cwids.get(0))
.expectNext(cwids.get(1))
.expectNext(cwids.get(2), cwids.get(3), cwids.get(4))
.expectComplete()
.expectSubscription()

37. StepVerifier
Flux<String> flux = Flux.fromIterable(cwids).take(5);
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
StepVerifier.create(flux)
.expectNext(cwids.get(0))
.expectNext(cwids.get(1))
.expectNext(cwids.get(2), cwids.get(3), cwids.get(4))
.expectComplete()
.verify();
.expectSubscription()

38. Operators: take
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
https://raw.githubusercontent.com/reactor/reactor-core/master/src/docs/marble/take.png
Flux.fromIterable(cwids)
.take(3)
...

39. Operators: map
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
https://raw.githubusercontent.com/reactor/reactor-core/master/src/docs/marble/map.png
Flux.fromIterable(cwids)
.map(cwid -> loadUser(cwid))
...

40. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
https://raw.githubusercontent.com/reactor/reactor-core/master/src/docs/marble/flatmap.png
Flux.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid))
...

41. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));

42. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}

43. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)

44. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))

45. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))

46. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))

47. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();

48. Operators: flatMap
Reactive Programming
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> loadUserAsMono(cwid));
?
private Mono<User> loadUserAsMono(String cwid) {
return Mono.fromCallable(() -> loadUser(cwid));
}
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();

49. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
Declarative Concurrency

50. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
Declarative Concurrency
.subscribeOn(Schedulers.parallel())

51. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
.subscribeOn(Schedulers.parallel())

52. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
.subscribeOn(Schedulers.parallel())

53. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
.subscribeOn(Schedulers.parallel())

54. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - After Flux.subscribe()
.subscribeOn(Schedulers.parallel())

55. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - After Flux.subscribe()
[par1] - emitter.next(1).subscribeOn(Schedulers.parallel())

56. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - After Flux.subscribe()
[par1] - emitter.next(1)
[par1] - subscriber.onNext(1)
.subscribeOn(Schedulers.parallel())

57. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - After Flux.subscribe()
[par1] - emitter.next(1)
[par1] - subscriber.onNext(1)
[par1] - emitter.complete()
.subscribeOn(Schedulers.parallel())

58. SubscribeOn
log.info("Before Flux.create()");
Flux<Integer> flux = Flux.create(emitter -> {
log.info("emitter.next({})", 1);
emitter.next(1);
log.info("emitter.complete()");
emitter.complete();
}) ;
log.info("After Flux.create()");
log.info("Before Flux.subscribe()");
flux.subscribe(
next -> log.info("subscriber.onNext({})", next),
error -> log.info("subscriber.onError({})", error),
() -> log.info("subscriber.onComplete()")
);
log.info("After Flux.subscribe()");
[main] - Before Flux.create()
[par1] – subscriber.onComplete()
Declarative Concurrency
[main] - After Flux.create()
[main] - Before Flux.subscribe()
[main] - After Flux.subscribe()
[par1] - emitter.next(1)
[par1] - subscriber.onNext(1)
[par1] - emitter.complete()
.subscribeOn(Schedulers.parallel())

59. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency

60. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
.subscribeOn(Schedulers.parallel())

61. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

62. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

63. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445).subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

64. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

65. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
[main] - Before Flux.fromIterable()

66. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
[main] - Before Flux.fromIterable()

67. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
[main] - Before Flux.fromIterable()

68. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
[main] - Before Flux.fromIterable()

69. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
[main] - Before Flux.fromIterable()

70. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
✓
[main] - Before Flux.fromIterable()

71. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid)))
;
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par1] - loadUser(75ad9445)
[par1] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
✓
[main] - Before Flux.fromIterable()
✗

72. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency

73. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
.subscribeOn(Schedulers.parallel())

74. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

75. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

76. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par2] - loadUser(75ad9445).subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

77. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par2] - loadUser(75ad9445)
[par3] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
[main] - Before Flux.fromIterable()

78. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par2] - loadUser(75ad9445)
[par3] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
[main] - Before Flux.fromIterable()

79. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par2] - loadUser(75ad9445)
[par3] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
✗
[main] - Before Flux.fromIterable()

80. SubscribeOn Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
);
Declarative Concurrency
[par1] - loadUser(7896c6eb)
[par2] - loadUser(75ad9445)
[par3] - loadUser(e2d4c51d)
.subscribeOn(Schedulers.parallel())
StepVerifier.create(users)
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
✗
[main] - Before Flux.fromIterable()
✓

81. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency

82. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)

83. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)
.thenAwait()

84. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))

85. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))

86. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))

87. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();

88. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
Supplier< > () ->
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();

89. Virtual Time Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
log.info("Before Flux.fromIterable()");
Flux<User> users = Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
StepVerifier
Declarative Concurrency
Supplier< > () ->
.withVirtualTime(users)
.thenAwait()
.expectNextMatches(hasCwid(cwids.get(0)))
.expectNextMatches(hasCwid(cwids.get(1)))
.expectNextMatches(hasCwid(cwids.get(2)))
...
.verifyComplete();
✓

90. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));

91. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
CONCURRENCY

92. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
TIMEOUT
CONCURRENCY

93. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
.retry(numRetries)
TIMEOUT
RETRY
CONCURRENCY

94. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
.retryWhen(errors -> errors.zipWith(Flux.range(0, MAX_VALUE), (err, idx) -> {
if (idx < numRetries) {
return Mono.just(err).delayElement(withExponentialBackoff(idx));
} else {
return Mono.error(err);
}
}).flatMap(Function.identity()))
TIMEOUT
RETRY WITH EXPONENTIAL BACKOFF
CONCURRENCY

95. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
.retryWhen(errors -> errors.zipWith(Flux.range(0, MAX_VALUE), (err, idx) -> {
if (idx < numRetries) {
return Mono.just(err).delayElement(withExponentialBackoff(idx));
} else {
return Mono.error(err);
}
}).flatMap(Function.identity()))
long ms = (long) Math.pow(10, idx);
return Duration.ofMillis(ms);
TIMEOUT
RETRY WITH EXPONENTIAL BACKOFF
CONCURRENCY

96. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
.retryWhen(errors -> errors.zipWith(Flux.range(0, MAX_VALUE), (err, idx) -> {
if (idx < numRetries) {
return Mono.just(err).delayElement(withExponentialBackoff(idx));
} else {
return Mono.error(err);
}
}).flatMap(Function.identity()))
TIMEOUT
RETRY WITH EXPONENTIAL BACKOFF
CONCURRENCY

97. Let‘s go wild ...
Declarative Concurrency
Flux
.fromIterable(cwids)
.flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.parallel()));
.timeout(Duration.ofMillis(250), Schedulers.single())
.retryWhen(errors -> errors.zipWith(Flux.range(0, MAX_VALUE), (err, idx) -> {
if (idx < numRetries) {
return Mono.just(err).delayElement(withExponentialBackoff(idx));
} else {
return Mono.error(err);
}
}).flatMap(Function.identity()))
.map(Either::<String, User>right)
.otherwiseReturn(left(cwid))
Flux<Either<String, User>> users =
TIMEOUT
RETRY WITH EXPONENTIAL BACKOFF
ERROR HANDLINGCONCURRENCY

98. Backpressure
Reactive
Streams
Akka
Streams
ReactorRxJava 2
Back-
pressure
Marble
Diagrams
Function Composition
with Higher Order
Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive
Extensions

99. Reactive Streams
§ Flow API in Java 9: java.util.concurrent.Flow
§ Standard for asynchronous stream processing
§ Pivotal, Lightbend, Netflix, Oracle, Red Hat and others
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Backpressure

100. Reactive Streams
public class Flow {
interface Processor<T, R> { ... }
interface Publisher<T> { ... }
interface Subscriber<T> { ... }
interface Subscription { ... }
}
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Backpressure

101. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

102. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

103. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

104. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

105. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

106. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

107. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

108. Subscriber
Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher

109. Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
ExecutorService executorService = new ThreadPoolExecutor(
10,
10,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(500)
);

110. Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
List<Future<User>> eventualUsers = cwids.stream()
.map(cwid -> executorService.submit(() -> loadUser(cwid)))
.collect(toList());
List<User> users = eventualUsers.stream()
.map(eventualUser -> {
try { return eventualUser.get(); }
catch (Exception e) { throw new RuntimeException(e); }
})
.collect(toList());

111. Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
java.util.concurrent.RejectedExecutionException:
Task java.util.concurrent.FutureTask@632ceb35 rejected
from java.util.concurrent.ThreadPoolExecutor@1c93f6e1[
Running, pool size = 10, active threads = 10,
queued tasks = 500, completed tasks = 0
]

112. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

113. Subscriber
request(3)
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

114. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

115. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

116. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

117. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

118. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

119. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

120. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

121. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription
request(2)

122. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

123. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

124. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

125. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

126. Subscriber
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
Publisher
Subscription

127. List<User> users = Flux.fromIterable(cwids)
.flatMap(cwid -> Mono
.fromCallable(() -> loadUser(cwid))
.subscribeOn(Schedulers.fromExecutor(executorService)))
.collectList()
.block();
Pulling and Pushing
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions

128. class FluxIterable<T> {
Iterable<? extends T> iterable;
FluxIterable(Iterable<? extends T> iterable) {
this.iterable = iterable;
}
// more than 500 lines of code
}
Pulling and Pushing: fromIterable
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
naive implementation
of fromIterable does
not enable backpressure
!

129. Pulling and Pushing: flatMap
Backpressure
Reactive
Streams
Akka Streams
ReactorRxJava 2
Backpressure
Marble Diagrams
Function Composition with Higher
Order Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive Extensions
https://raw.githubusercontent.com/reactor/reactor-core/v3.0.6.RELEASE/src/docs/marble/flatmapc.png

130. Conclusion
Reactive
Streams
Akka
Streams
ReactorRxJava 2
Back-
pressure
Marble
Diagrams
Function Composition
with Higher Order
Functions
Functional
Programming
Declarative
Programming
REACTIVE
PROGRAMMING
REACTIVE
SYSTEMS
Reactive
Extensions

131. What‘s more?
§ Concurrency with publishOn and ParallelFlux
§ Declarative Error Handling
§ Logging and Monitoring
§ Cold Streams vs. Hot Streams
§ C10K and Non-blocking IO
§ Reactive Streams in the Web
Conclusion

132. DISCUSS!
Conclusion