This document provides an overview of reactive programming and how it can be applied to Java applications using frameworks like Project Reactor and Spring WebFlux. It defines reactive programming as composing asynchronous and event-based streams using non-blocking operators. It discusses how reactive streams like Flux and Mono work in Project Reactor and how Spring WebFlux allows building reactive web applications that can handle high concurrency with low latency. Examples are provided of building reactive data repositories, handling streaming responses with backpressure, and orchestrating remote service calls reactively.

1. Reactive Programming
for Java Developers
Constantin PopaEngineering #5
16:00-16:45
Reactive Programming
for Java Developers
Constantin Popa

2. Reactive Programming
for Java Developers
Constantin Popa

3. First
a
Survey

4. Who here uses…
Java 8
Spring framework
RxJava/Reactor
Spring WebFlux

5. AGENDA
Reactive Programming 101
Reactive streams – Project Reactor
Reactive web apps – Spring WebFlux

6. Reactive Programming 101

7. Why?
because blocking is evil

8. sync&blocking
main thread
I/O
time
main thread
resume processing

9. async&blocking
main thread
time
wait & join
I/O
I/O

10. async&nonblocking
main thread
time
Event loop
worker thread
I/O request
I/O request
I/O Data
available

11. how do achieve that?
without losing your mind…

12. Reactive Programming

13. “Composing asynchronous &
event-based streams
using non-blocking operators”

14. We don’t sacrifice much
callbacks?
Future? CompletableFuture?

15. Pull? Push!

16. vs
Iterable
-
Iterator
Publisher
-
Subscriber

17. Data in Flux

18. Publisher Subscriber
produces consumes
push events
Feedback
interfaces from
Reactive Streams
specification
now part of Java 9, under
java.util.concurrent.Flow
Subscriber<T>
onNext(T)
onComplete()
onError(Throwable)
onSubscribe(Subscription)
0..N elements
+
0..1 (complete | error)
backpressure
These interfaces
don’t do much…
Subscription.request(n)
Subscription.cancel()

19. Project Reactor

20. Flux<T>
generates 0..N elements

21. Marble diagrams

22. Give the Flux a second chance

23. Interactive marble diagrams on http://rxmarbles.com
(most map to Reactor operators)

24. Mono<T>
generates 0..1 elements

26. Reactive streams vs Java 8 streams
”The design center for Streams is mostly about data that can be accessed
with no latency (either from data structures or generating functions)”
“The design center for Rx is about infinite streams of events which
may arrive asynchronously.”
Brian Goetz

27. an Rx-inspired API
with a vocabulary of operators similar to RxJava

28. Flux.range map
filter
buffer Subscriber
Nothing happens
until you subscribe

32. Flux.range(1,3) map
filter
buffer Subscriber
123

33. Flux.range(1,3)
.map( number -> toShape())
.filter(shape -> isCircle())
.buffer()
.subscribe(shape -> printShape())

34. More awesomeness
async sub-processes with flatMap

36. Reactor is
concurrency-agnostic

37. Flux.range(1,3)
.map( number -> toShape())
.filter(shape -> isCircle())
.buffer()
.subscribe(shape -> printShape())

38. Flux.range(1,3)
.subscribeOn(Schedulers.elastic())
.map(number -> toShape())
.filter(shape -> isCircle())
.buffer()
.publishOn(Schedulers.immediate())
.subscribe(shape -> printShape())

39. Schedulers.single()
Schedulers.parallel()
Schedulers.elastic()
Schedulers.immediate()

40. Reactive web applications Spring
WebFlux

41. Use case #1
Reactive data repository

42. Let's recap:
HTTP GET with reactive data repository
Designed to work with both Spring MVC and Spring WebFlux
Simply return reactive types(Flux, Observable) from @Controller
@GetMapping("/cars")
@ResponseBody
public Flux<Car> getCars() {
return this.repository.findAll();
}

43. Flux<T>:
finite collection or infinite stream?

44. Use media type to decide

45. “application/json”
finite collection(JSON array)

46. “text/event-stream”
“application/stream+json”
infinite stream

47. DEMO

48. Use case #2
Response stream with backpressure

49. Handling backpressure
request(n)->write->flush->repeat

50. DEMO

51. Let’s recap:
HTTP GET with streaming response
Simply return reactive types(Flux, Observable) from @Controller
Backpressure handling on both Spring MVC and Spring WebFlux

52. Use case #3
Reactive remote service orchestration

53. DEMO

54. Let’s recap:
Reactive webclient
Orchestrate non-blocking, nested remote service calls with ease.
Similar to reactive data access

57. What WebFlux is good for:
High traffic
High concurrency with less hardware resources
Latency, streaming scenarios

58. Summary
Quite a steep learning curve
Doesn’t fit all scenarios, if it ain’t broken, don’t fix it
It’s fun time to be a Java developer!
Spring WebFlux and Reactor unlock the gates for easy Reactive
Programming on the server side and not only