Reactive Features of MicroProfile
You Need To Learn
Ondro Mihályi http://www.payara.fish
@ONDROMIH

@ONDROMIH
Agenda

@ONDROMIH
Agenda
Flowable.fromPublisher(p)
.map(mapper)
.subscribe();
Stream.generate(s)
.map(mapper)
.forEach();

@ONDROMIH
Agenda
org.reactivestreams (Java 8+)
java.util.concurrent.Flow (Java 9+)

@ONDROMIH
Agenda
<dependency>
<groupId>
org.eclipse.microprofile
</groupId>
<artifactId>
microprofile
</artifactId>
<scope>provided</scope>
</dependency>
Reactive
Streams

@ONDROMIH
Goals to Solve
●
Better user experience
●
Save resources/costs
●
Keep up with massive loads
●
Handle failures (recover)

@ONDROMIH
Traditional Thread Usage
●
Dedicated thread per
request
●
Threads acquired from
a pool

@ONDROMIH

@ONDROMIH
Reactive in a nutshell

@ONDROMIH
Reactive in a nutshell

@ONDROMIH
Asynchronous nature
●
To avoid blocking threads, responses must
be processes asynchronously (later)
●
Callbacks, Promises, CompletionStage,
Observers

@ONDROMIH
Code comparison
Simple blocking code
data = readData(query);
/* runs after data
retrieved */
response =
buildResponse(data);
return response;
Asynchronous code
readData(query)
// after data retrieved
.thenApply(
buildResponse)
.thenAccept(
sendResponse);
// runs immediately
return;

@ONDROMIH
Existing asynchronous APIs
●
Java SE: CompletionStage
●
RxJava library: Flowable
●
Spring Reactor library: Flux

@ONDROMIH
Reactive >= asynchronous
●
Process data as soon as possible (streams)
●
Recover from failures
●
Control data flow (protect the consumer)

@ONDROMIH
Reactive pipeline
●
Data stream
– Subscribe → Process → Publish
– Handle:
●
Data, Error, Completion

@ONDROMIH
Existing Stream/Pipeline APIs
●
Java SE: Streams – no subscribe, publish
●
Reactive Streams spec – no processing
●
Java SE 9+: Flow – as Reactive Streams
●
Libraries: RxJava, Project Reactor

@ONDROMIH
Java Stream API
stream
.filter(isValid)
.map(toJson)
.peek(logData)
.forEach(sendData);

@ONDROMIH
Java Stream API
●
Stream processing API, but…
●
No way to subscribe!
●
Terminal operations blocking
●
An exception terminates processing

@ONDROMIH
RxJava pipeline
Flowable.fromPublisher(p)
.filter(isValid)
.map(toJson)
.doOnEach(logData)
.doOnError(handleError)
.doFinally(releaseResources)
.subscribe(sendData);

@ONDROMIH
RxJava pipeline
●
Complete solution but…
●
Complicated API
●
Incompatible with other reactive libraries
●
Reactive Streams and Java SE Flow
– Standard interface among reactive APIs

@ONDROMIH
MicroProfile Reactive
●
MicroProfile – brings common APIs
– collaboration of vendors and library creators
●
Reactive APIs
– Stream processing
– Message passing
– Fault Tolerance

@ONDROMIH
MicroProfile pipeline
ReactiveStreams.fromPublisher(p)
.filter(isValid)
.map(toJson)
.peek(logData)
.onError(handleError)
.onComplete(releaseResources)
.forEach(sendData)
.run();

@ONDROMIH
Java Streams vs. MicroProfile
ReactiveStreams
.fromPublisher(p)
.filter(isValid)
.map(toJson)
.peek(logData)
.onError(handleErr)
.onComplete(release)
.forEach(sendData)
.run();
stream
.filter(isValid)
.map(toJson)
.peek(logData)
.forEach(sendData);

@ONDROMIH
RxJava vs. MicroProfile
ReactiveStreams
.fromPublisher(p)
.filter(isValid)
.map(toJson)
.peek(logData)
.onError(handleErr)
.onComplete(release)
.forEach(sendData)
.run();
Flowable
.fromPublisher(p)
.filter(isValid)
.map(toJson)
.doOnEach(logData)
.doOnError(handle)
.doFinally(release)
.subscribe(send);

@ONDROMIH
MicroProfile operators
●
Consuming (findFirst, forEach, collect)
●
Filtering (filter, limit, skip)
●
Transforming (map, flatMap)
●
Peeking, Connecting, ErrorHandlig
●
Javadoc with diagrams:
https://download.eclipse.org/microprofile/microprofile-react
ive-streams-operators-1.0/apidocs/

@ONDROMIH
MicroProfile plus RxJava
org.reactivestreams.Publisher pub =
ReactiveStreams.fromPublisher(p)
.map(toJson)
.onError(handleError)
.onComplete(releaseResources)
.buildRs();
Flowable
.fromPublisher(pub)
.window(3)
.subscribe(sendBatch);

@ONDROMIH
Extended Reactive Pipeline
●
Data stream
– Receive Message → Subscribe →
Process → Publish → Send Message

@ONDROMIH
Messaging pipeline

@ONDROMIH
MicroProfile message API
@Outgoing("source")
String json() {…}
@Incoming("source")
@Outgoing("target")
Entity convertJson(String json) {…}
@Incoming("target")
void method(Entity entity) {…}

@ONDROMIH
MicroProfile message API
@Incoming("source")
@Outgoing("target")
Publisher<Message<Item>>
splitList(Message<ItemList> list) {…}

@ONDROMIH
Message acknowledgement
●
Automatic: Pre- and Post-processing
●
Manual: Message.ack()

@ONDROMIH
Connectors
●
Internal channels (by default)
●
Pluggable connectors to remote brokers
– CDI beans, implement IncomingConnectorFactory
and/or OutgoingConnectorFactory
– Examples: Kafka, MQTT, Camel, AMQP

@ONDROMIH
Fault Tolerance
●
Annotations on methods of CDI beans
●
Retry, Circuit breaker, Fallback, …
●
Support CompletionStage return type

@ONDROMIH
Fault Tolerance API
@Asynchronous
@Retry
@Fallback(fallbackMethod="handleError")
public CompletionStage<List> load() {
return ReactiveStreams
.fromPublisher(retrieveData())
.filter(isValid)
.toList()
.run();
}

@ONDROMIH
MicroProfile implementations
●
Payara, Helidon, OpenLiberty, Quarkus,
SmallRye, …
●
Around 10 runtimes for full MicroProfile
●
Various libraries support a subset of APIs

@ONDROMIH
Thank you!
●
https://www.payara.fish
●
https://microprofile.io
●
https://www.reactivemanifesto.org
●
http://www.reactive-streams.org
●
https://github.com/eclipse/microprofile-reactive-streams-operators/releases
●
https://github.com/eclipse/microprofile-reactive-messaging/releases

Not using the Payara Platform yet? Download the open
source software: Payara Server or Payara Micro​
https://payara.fish/downloads​
​
Need support for the Payara Platform?​
https://payara.fish/support​