The document is a guide on transitioning from traditional Java EE to reactive microservice design, focusing on the benefits and methods of implementing reactive programming. It discusses the challenges of waiting on resources in traditional setups and highlights improvements through reactive design patterns, such as using CompletableFuture and event messaging. Additionally, it emphasizes the importance of scalability and handles messaging with the Payara CDI event bus while advocating for gradual enhancements within Java EE and MicroProfile.

1. A step-by-step guide from traditional
Java EE to reactive microservice design
Ondrej Mihályi
@OndroMih https://ondro.inginea.eu

2.  Engineer at Payara
 Java EE developer,
lecturer
 MicroProfile member
 Czech JUG leader
Ondro
Mihályi
Web:
ondro.inginea.eu
www.payara.fish
Twitter:
@OMihalyi

3.  Reactive improvements
 Separation to micro-svc
 Deploy with Docker
https://github.com/OndrejM-demonstrations/
ReactiveWay-cargotracker-ext
Agenda

4. @ONDROMIH
Majority of the enterprise code
Request started
→ resource required (DB, WS, files)
→ request the resource
→ the resource is slow
WHAT DO WE DO? (hint: it’s quite natural)

5. @ONDROMIH
We simply...

6. @ONDROMIH
We simply...
...WAIT
No shame, we all do it
 Simple
 Thread-safe
 Enough in most cases

7. @ONDROMIH
But what if...

8. @ONDROMIH
If waiting is too long...
 Thread resources are wasted
 Processing may slow down or
halt if all threads waiting
 Users don’t receive a timely
feedback
 Failures lead to more failures

9. @ONDROMIH
If waiting is too long...
 Thread resources are wasted
 Processing may slow down or
halt if all threads waiting
 Users don’t receive a timely
feedback
 Failures lead to more failures

10. @ONDROMIH
Reactive manifesto
http://www.reactivemanifesto.org/

11. @ONDROMIH
Reactive idea in a nutshell
Single-threaded Reactive - not bound to a thread

12. @ONDROMIH
Threads reused between calls

13. @ONDROMIH
Example traditional application
We’re going to
improve it
reactively
Original project:
https://github.com/javaee/cargotracker
Reactive improvements:
https://github.com/OndrejM-demonstrations/Rea
ctiveWay-cargotracker-ext

14. @ONDROMIH
Traditional design

15. @ONDROMIH
More reactive design

16. @ONDROMIH
Chaining callbacks
CompletableFuture in Java 8
 complete, completeExceptionally
 thenAccept, thenApply, thenCompose
 exceptionally
Alternatively use third-party libraries
 RxJava observables

17. @ONDROMIH
3. Messages
WebSocket, Server-Sent Events
CDI events
 Light-weight but extensible API
 Events don’t cross JVM boundaries
 Can we turn them into messages?

18. @ONDROMIH
Even more reactive design

19. @ONDROMIH
Simple messaging and caching
Payara CDI Event Bus
 Async events on all nodes
 On top of CDI events
 Uses Hazelcast
JCache API
 Scalable distributed
memory
 Replication and failover
@Inject @Outbound
Event<MyMsg> ev;
/* handle in the same
or a different JVM: */
void handle(@Observes
@Inbound MyMsg ev) {
… }

20. @ONDROMIH
Multiple threads, need to track origin and arrival of
responses, errors may be unnoticed, new design
patterns
Don’t over-engineer, but leave
space for future improvements
Java EE and MicroProfile allow for gradual
improvements
Reactive programming isn’t easy

21. @ONDROMIH
Thank you!