Ready for a deep dive into the world's most challenging programming paradigm? Reactive programming can simplify asynchronous and event-driven applications, but without a strong understanding, it can lead to frustration, recurring patchwork, missed deadlines, and costly bugs. In this intensive three-hour session, we'll transition a traditional Spring application to WebFlux, revealing patterns and aanti-patterns when working with repositories, REST APIs, queues, and legacy libraries. You'll gain a clear understanding of often overlooked but critical aspects like subscribe signal, errors, cancellation, and signal loss. As a bonus, we'll debate the future of Reactive vs Virtual Threads, production-ready in Java 21. This session is crucial for developers already working with reactive programming or those intending to make the leap.

2. victorrentea.ro/training-offer
👋 Hi, I'm Victor Rentea 🇷🇴 PhD(CS): VictorRentea.ro
Java Champion, 18 years of code, 10 years of teaching
Consultant & Trainer for 120+ companies:
❤️ Clean Code, Architecture, Unit Testing
🛠 Spring, Hibernate, Reactive/WebFlux
⚡️ Java Performance, Secure Coding 🔐
Lots of Conference Talks on YouTube
Founder of European Software Crafters Community (6K members)
🔥 Free 1-hour webinars, after work 👉 victorrentea.ro/community
Past events on youtube.com/vrentea
Father of 👧👦, servant of a 🐈, weekend gardener 🌼 VictorRentea.ro

3. 3
Reactive Programming
unbounded
if no backpressure

4. 4
tl;dr
This session is not for children !

5. 5
Crash Course in
Reactive Programming

6. 6
Reactive Programming
is programming with
asynchronous data
streams
Watch: The introduction to Reactive Programming you've been missing - https://gist.github.com/staltz/868e7e9bc2a7b8c1f754

7. 7

8. 8

9. 9

10. 10

11. 11

12. 12

13. 13

14. 14
Signals
unbounded
if no backpressure

15. 15
Operator

16. 16
Subscriber upstream ↑
Publisher downstream ↓
Operator

17. 17
.buffer(Duration.ofSeconds(2))
.flatMap(postIds -> postRepo.findAllById(postIds))
.map(LikedPosts::new)
Subscriber upstream ↑
Publisher downstream ↓
Operator

18. 18
Project Reactor
is for Backend Java
what RxJava is for Android

19. 20
If you have a Spring MVC application that works fine, there is no need to
change. Imperative programming is the easiest way to write, understand,
and debug code. You have maximum choice of libraries, since most are
blocking.
If you have a large team, keep in mind the steep learning curve
in the shift to non-blocking, functional, and declarative programming.
A practical way to start without a full switch is to use the reactive WebClient.
Beyond that, start small and measure the benefits.
We expect that, for a wide range of applications, the shift is unnecessary.
https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#webflux-framework-choice

20. 21

21. 22
- the whole story -

22. 23

23. 24
Flux
Emits 0..N items🔵 + COMPLETE| or ERROR❌
...
Many elements
Flux.just(1,2)
Flux.fromIterable(list)
One element Flux.just("a")
No element Flux.empty()
Infinite Flux
... Flux.interval()
KafkaReceiver.receive()
...
Error Flux.error()
Δt
time

24. 25

25. 26
Mono
Emits 0..1 items🔵 + COMPLETE| or ERROR❌
No element Mono.empty()
One item Mono.just(1)
error Mono.error(new Ex(..))
Best Practice: If a function return nothing
declare its return type: Mono<Void>
eg. sendEmail(..): Mono<Void>
Data items cannot be null in Reactor;
 instead, return a Mono.empty().
⚠️ How do operator handle empty?

26. 27
Marble Diagrams
(THE tool to self-documenting about operators)

27. 28
Mono
Flux idFlux.flatMap(repo::findById)

28. 29
Fundamental Reactive Programming Rules
Nothing happens until you subscribe
Avoid .subscribe()/.block()
Instead, return a Publisher (Mono/Flux)

29. 30
CodE

30. 31

31. 32 © VictorRentea.ro
a training by
Spring WebFlux Lessons
• A method calling network must return a Publisher. Network call is sent at subscribe↑
• A method returning Publisher must not BLOCK nor THROW (return an error() instead)
• BLOCK is only legal via fromCallable({blocking code}).subscribedOn(boundedElastic())
• Every cold Publisher must be subscribed (once!) for a network call to happen
• Avoid keeping Publisher instances in variables ⤴️
• Mind the signals in Marble Diagrams⚠️: behavior on empty↓, cancel↑, subscribe↑
• Request metadata 🪄🎩 is propagated via ReactorContext instead of ThreadLocal
• Return your Publishers to Spring: to subscribe, pass RC⤴️ and manage cancellation
• Avoid doing .subscribe() and .block() ⤴️, except at startup, blocking MQ listeners, timers
• Master Functional Programming 🪄, Favor immutability to avoid race bugs💀
• Learn Reactor⚛️ operators, avoid excessive nested lambdas   , small functions❤️
• Take it baby-steps: start migration with WebClient..block() and Mono.fromRunnable()
• Infinite Flux/Sink: beware of cancellation⚠️

32. 33
Default way of handling HTTP requests
Boundary
System
Service A Service B DB
time
API call
(http request)
thread released
(http response sent back)
thread blocked
( 1 / 200 in the thread pool )
WASTE OF RESOURCES
STARVATION RISK
API call
(http request)
API call
(http request)
Query
(JDBC call)
⭐️ Fixed by Java 21

33. 34 © VictorRentea.ro
a training by
Virtual Threads (Project Loom)
(included in Java 19 in preview)
When a Virtual Thread blocks for any reason (eg. DB, API call, File access, Locks),
the JVM reuses the underlying OS thread to execute other runnable virtual threads
Therefore, a Virtual Thread is very cheap
Virtual Threads are very light:
• We can take 100.000s requests in parallel even if our code blocks
• No need for thread pools anymore
• Structured concurrency can be used to fork/join threads to handle cancellations
• ThreadLocal data needs to be kept small
•  Can pin on an OS thread or  Can be unfair if non-interruptible CPU work

34. 35 © VictorRentea.ro
a training by
Virtual Threads can handle huge number
of independent parallel requests,
without the risks of Reactive Programming
☠️
Use Cases for Reactive Programming:
 Handling async streams of data signals: IoT, MQ
 Server <-> Browser bidirectional comm
 Streaming large data in transit