SlideShare a Scribd company logo

Declarative Concurrency with Reactive Programming

F
Florian Stefan

The document discusses declarative concurrency with reactive programming, highlighting the use of reactive streams and frameworks like Akka Streams and Reactor. It emphasizes concepts such as back-pressure, function composition, and the advantages of reactive programming in building responsive, resilient, and scalable systems. Additionally, it provides examples of stream processing and factory methods in reactive programming.

Technology
1 of 132
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
Declarative Concurrency with Reactive Programming Florian Stefan | #ebaytechtalk
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
Why am I here? § C10K problem in IoT project § Spring, Play, Netty, Node.js § Legacy Systems / Microservice Architectures Introduction
REACTIVE Introduction
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
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
The Reactive Manifesto Reactive Systems responsive resilient event-driven scalable
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 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)
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()
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()
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()
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()
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()
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()
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) ...
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)) ...
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)) ...
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));
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)); }
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)
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)))
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)))
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)))
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();
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();
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 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())
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())
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())
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())
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())
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())
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())
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())
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())
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 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())
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()
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()
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()
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()
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()
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()
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()
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()
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()
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()
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() ✗
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 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())
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()
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()
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()
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()
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()
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()
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() ✓
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
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)
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()
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)))
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)))
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)))
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();
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();
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(); ✓
Let‘s go wild ... Declarative Concurrency Flux .fromIterable(cwids) .flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid)) .subscribeOn(Schedulers.parallel()));
Let‘s go wild ... Declarative Concurrency Flux .fromIterable(cwids) .flatMap(cwid -> Mono.fromCallable(() -> loadUser(cwid)) .subscribeOn(Schedulers.parallel())); CONCURRENCY
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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) );
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());
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 ]
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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 !
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
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
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
DISCUSS! Conclusion

More Related Content

PDF
Project Reactor Now and Tomorrow
VMware Tanzu
 
PDF
Being Functional on Reactive Streams with Spring Reactor
Max Huang
 
PDF
M|18 Architectural Overview: MariaDB MaxScale
MariaDB plc
 
PDF
ProxySQL and the Tricks Up Its Sleeve - Percona Live 2022.pdf
Jesmar Cannao'
 
PDF
HandsOn ProxySQL Tutorial - PLSC18
Derek Downey
 
PDF
MySQL InnoDB Cluster - Group Replication
Frederic Descamps
 
PDF
MySQL GTID Concepts, Implementation and troubleshooting
Mydbops
 
PPTX
Introduction to gRPC
Chandresh Pancholi
 
Project Reactor Now and Tomorrow
VMware Tanzu
 
Being Functional on Reactive Streams with Spring Reactor
Max Huang
 
M|18 Architectural Overview: MariaDB MaxScale
MariaDB plc
 
ProxySQL and the Tricks Up Its Sleeve - Percona Live 2022.pdf
Jesmar Cannao'
 
HandsOn ProxySQL Tutorial - PLSC18
Derek Downey
 
MySQL InnoDB Cluster - Group Replication
Frederic Descamps
 
MySQL GTID Concepts, Implementation and troubleshooting
Mydbops
 
Introduction to gRPC
Chandresh Pancholi
 

What's hot (20)

PDF
MariaDB MaxScale
MariaDB plc
 
PDF
Getting started with MQTT - Virtual IoT Meetup presentation
Christian Götz
 
PPT
Design Pattern For C# Part 1
Shahzad
 
PDF
PostgreSQL High Availability in a Containerized World
Jignesh Shah
 
PDF
PostgreSQL Replication High Availability Methods
Mydbops
 
PDF
Galera Cluster for MySQL vs MySQL (NDB) Cluster: A High Level Comparison
Severalnines
 
PDF
MySQL InnoDB Cluster: High Availability Made Easy!
Vittorio Cioe
 
PDF
MySQL-InnoDB
Mayank Prasad
 
PDF
SQL Transactions - What they are good for and how they work
Markus Winand
 
PDF
[2019] 200만 동접 게임을 위한 MySQL 샤딩
NHN FORWARD
 
PDF
Solid NodeJS with TypeScript, Jest & NestJS
Rafael Casuso Romate
 
PDF
Introduction to Spring WebFlux #jsug #sf_a1
Toshiaki Maki
 
PDF
OpenStack DevStack Install - 2부 (Multi-nodes)
Ian Choi
 
PDF
Taking Security Groups to Ludicrous Speed with OVS (OpenStack Summit 2015)
Thomas Graf
 
PDF
Introduction to gRPC
Prakash Divy
 
PDF
Action Jackson! Effective JSON processing in Spring Boot Applications
Joris Kuipers
 
PDF
All about Zookeeper and ClickHouse Keeper.pdf
Altinity Ltd
 
PDF
Understanding PostgreSQL LW Locks
Jignesh Shah
 
PDF
MySQL/MariaDB Proxy Software Test
I Goo Lee
 
PDF
Networking in Java with NIO and Netty
Constantine Slisenka
 
MariaDB MaxScale
MariaDB plc
 
Getting started with MQTT - Virtual IoT Meetup presentation
Christian Götz
 
Design Pattern For C# Part 1
Shahzad
 
PostgreSQL High Availability in a Containerized World
Jignesh Shah
 
PostgreSQL Replication High Availability Methods
Mydbops
 
Galera Cluster for MySQL vs MySQL (NDB) Cluster: A High Level Comparison
Severalnines
 
MySQL InnoDB Cluster: High Availability Made Easy!
Vittorio Cioe
 
MySQL-InnoDB
Mayank Prasad
 
SQL Transactions - What they are good for and how they work
Markus Winand
 
[2019] 200만 동접 게임을 위한 MySQL 샤딩
NHN FORWARD
 
Solid NodeJS with TypeScript, Jest & NestJS
Rafael Casuso Romate
 
Introduction to Spring WebFlux #jsug #sf_a1
Toshiaki Maki
 
OpenStack DevStack Install - 2부 (Multi-nodes)
Ian Choi
 
Taking Security Groups to Ludicrous Speed with OVS (OpenStack Summit 2015)
Thomas Graf
 
Introduction to gRPC
Prakash Divy
 
Action Jackson! Effective JSON processing in Spring Boot Applications
Joris Kuipers
 
All about Zookeeper and ClickHouse Keeper.pdf
Altinity Ltd
 
Understanding PostgreSQL LW Locks
Jignesh Shah
 
MySQL/MariaDB Proxy Software Test
I Goo Lee
 
Networking in Java with NIO and Netty
Constantine Slisenka
 
Ad

Similar to Declarative Concurrency with Reactive Programming (20)

PDF
Reactive Programming in Java and Spring Framework 5
Richard Langlois P. Eng.
 
PDF
Reactive systems
Naresh Chintalcheru
 
PDF
Reactive Programming in Java by Mario Fusco - Codemotion Rome 2015
Codemotion
 
PDF
Reactive Programming for a demanding world: building event-driven and respons...
Mario Fusco
 
PDF
Reactive Applications in Java
Alexander Mrynskyi
 
PPTX
Mario Fusco - Reactive programming in Java - Codemotion Milan 2017
Codemotion
 
PDF
Reactive Everywhere
trion development GmbH
 
PDF
Next generation of frontend architectures
luca mezzalira
 
PDF
Buy ebook Functional Reactive Programming 1st Edition Stephen Blackheath chea...
wongazarok
 
PDF
Embracing Reactive Streams with Java 9 and Spring 5
Wilder Rodrigues
 
PPT
Reactive programming with examples
Peter Lawrey
 
PDF
Reactive mesh
Kalin Maldzhanski
 
PPTX
Reactive solutions using java 9 and spring reactor
OrenEzer1
 
PPTX
Reactive programming
saykopatt
 
PDF
Reactive programming with Pivotal's reactor
VMware Tanzu
 
PDF
ReactiveX
BADR
 
PDF
Reactive Card Magic: Understanding Spring WebFlux and Project Reactor
VMware Tanzu
 
PDF
I have a stream - Insights in Reactive Programming - Jan Carsten Lohmuller - ...
Codemotion
 
PDF
Workshop: Event-sourced system through Reactive Streams
sterkje
 
PPTX
Workshop: Event-sourced system through Reactive Streams
Kristof Van Sever
 
Reactive Programming in Java and Spring Framework 5
Richard Langlois P. Eng.
 
Reactive systems
Naresh Chintalcheru
 
Reactive Programming in Java by Mario Fusco - Codemotion Rome 2015
Codemotion
 
Reactive Programming for a demanding world: building event-driven and respons...
Mario Fusco
 
Reactive Applications in Java
Alexander Mrynskyi
 
Mario Fusco - Reactive programming in Java - Codemotion Milan 2017
Codemotion
 
Reactive Everywhere
trion development GmbH
 
Next generation of frontend architectures
luca mezzalira
 
Buy ebook Functional Reactive Programming 1st Edition Stephen Blackheath chea...
wongazarok
 
Embracing Reactive Streams with Java 9 and Spring 5
Wilder Rodrigues
 
Reactive programming with examples
Peter Lawrey
 
Reactive mesh
Kalin Maldzhanski
 
Reactive solutions using java 9 and spring reactor
OrenEzer1
 
Reactive programming
saykopatt
 
Reactive programming with Pivotal's reactor
VMware Tanzu
 
ReactiveX
BADR
 
Reactive Card Magic: Understanding Spring WebFlux and Project Reactor
VMware Tanzu
 
I have a stream - Insights in Reactive Programming - Jan Carsten Lohmuller - ...
Codemotion
 
Workshop: Event-sourced system through Reactive Streams
sterkje
 
Workshop: Event-sourced system through Reactive Streams
Kristof Van Sever
 
Ad

Recently uploaded (20)

PDF
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
PPTX
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
PPTX
Big Data Technologies - Introduction.pptx
kuthubussaman1
 
PDF
Empathic Computing: Creating Shared Understanding
Mark Billinghurst
 
PDF
Optimiser vos workloads AI/ML sur Amazon EC2 et AWS Graviton
Julien SIMON
 
PDF
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 
PDF
The Rise and Fall of 3GPP – Time for a Sabbatical?
3G4G
 
PPTX
Cloud computing and distributed systems.
kkkkkhan
 
PDF
TokAI - TikTok AI Agent : The First AI Application That Analyzes 10,000+ Vira...
SOFTTECHHUB
 
PDF
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
PDF
A comparative analysis of optical character recognition models for extracting...
IAESIJAI
 
PDF
Agricultural_Statistics_at_a_Glance_2022_0.pdf
SandeepSingh286037
 
PDF
Advanced methodologies resolving dimensionality complications for autism neur...
IAESIJAI
 
PDF
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
Akar16
 
PDF
Unlocking AI with Model Context Protocol (MCP)
Brian McKeiver
 
PDF
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
PDF
Assigned Numbers - 2025 - Bluetooth® Document
Bloombase
 
PPTX
MYSQL Presentation for SQL database connectivity
Swati270511
 
PPTX
sap open course for s4hana steps from ECC to s4
sreeni2106invites
 
PDF
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
Big Data Technologies - Introduction.pptx
kuthubussaman1
 
Empathic Computing: Creating Shared Understanding
Mark Billinghurst
 
Optimiser vos workloads AI/ML sur Amazon EC2 et AWS Graviton
Julien SIMON
 
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 
The Rise and Fall of 3GPP – Time for a Sabbatical?
3G4G
 
Cloud computing and distributed systems.
kkkkkhan
 
TokAI - TikTok AI Agent : The First AI Application That Analyzes 10,000+ Vira...
SOFTTECHHUB
 
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
A comparative analysis of optical character recognition models for extracting...
IAESIJAI
 
Agricultural_Statistics_at_a_Glance_2022_0.pdf
SandeepSingh286037
 
Advanced methodologies resolving dimensionality complications for autism neur...
IAESIJAI
 
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
Akar16
 
Unlocking AI with Model Context Protocol (MCP)
Brian McKeiver
 
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
Assigned Numbers - 2025 - Bluetooth® Document
Bloombase
 
MYSQL Presentation for SQL database connectivity
Swati270511
 
sap open course for s4hana steps from ECC to s4
sreeni2106invites
 
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 

Declarative Concurrency with Reactive Programming

  • 1. Declarative Concurrency with Reactive Programming Florian Stefan | #ebaytechtalk
  • 2. Who am I? § Florian Stefan § [email protected] | @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
  • 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