smallrye-mutiny | Intuitive Event-Driven Reactive Programming Library | Reactive Programming library

By returning a Uni, you're basically saying that the response is complete when the Uni completes. What you want is to run the action on a thread pool and return a complete response (Uni or not, that doesn't matter).

By the way, you're creating an extra thread pool in the method, for each request, and don't shut it down. That's wrong. You want to create one thread pool for all requests (e.g. in a @PostConstruct method) and ideally also shut it down when the application ends (in a @PreDestroy method).

The problem with Future is that it's a blocking API and, unlike CompletionStage, there is no way to chain a stream of operations.

However, Mutiny has a way to deal with blocking API:

Mutiny uses an Emitter when integrating with callback-based APIs;

https://smallrye.io/smallrye-mutiny/getting-started/creating-unis

So MyRequestService, or an underlying callback object, needs to implement an UniEmitter Consumer. But first, to become Reactive, my old blocking REST endpoint needs to return Uni instead of MyJsonResult;

The ServiceResource just forwards the call to the Service.

MyRequestService creates a MyJsonResultConsumer and delivers this to the Mutiny Emitter. The resulting Uni is returned to the ServiceResource.

Finally MyJsonResultConsumer is here the actual callback object; method ready() calls complete() on the UniEmitter concluding the callback towards Mutiny.

Remember that Mutiny needs to provide the UniEmitter with a call(back) to accept(), so you should check for null pointers (or use a Semaphore oid). 👮🏻‍♂️

Quarkus can be reactive or non reactive, it depends which extensions you choose to use.

Hibernate ORM Panache is for when you want to access the database in a non reactive way using Hibernate ORM and Panache. The same is true for JDBC, it's not reactive so you have to use something else if you want your whole app to be reactive.

In this scenario, you probably want to try these two extensions:

• quarkus-hibernate-reactive-panache: See the Hibernate Reactive with panache quickstart for an example
• quarkus-reactive-mysql-client: For allowing reactive access to the db. See the guide for Vert.x SQL Clients on the quarkus website

On the Quarkus website, there is also an intro on reactive for Quarkus.

Example of how to use the Vert.x SQL client from the guide:

If I understand correctly, you want to execute a set of async operations and combine them. For this, you can do something like:

I don't believe there is a built-in/better way to do this.

Mutiny generally prizes itself on having a "cut-down" set of operators in its core, and letting you build up other, more complex operators as needed. They're trying to avoid the reactor situation where you 100+ methods on a couple of core types, and without a lot of background knowledge it's often difficult to know what ones are relevant.

IMHO that's no bad thing. Other reactive frameworks definitely have these built-in sort() operators, but there's a danger here - people assume they can still treat them as infinite, magically sorted publishers, because there's no sign of any collections anywhere. You can't of course - internally these frameworks have to maintain an underlying collection to sort the data, and then just output the contents of that when the stream is complete. This isn't that clear however, and ignorance of this fact can often lead to unintended slowdowns and OutOfMemoryError. On the contrary, in your example, it's immediately obvious that this stream uses an underlying collection for sorting your data.

There's just one minor thing I'd change in your example, but not really related to your question - I'd use:

list.stream().sorted().collect(Collectors.toList())

...in your map call instead of sorting a mutable list. Mutating data structures in a reactive stream is a bit of a code smell.

Instead of .ifNoItem().after(Duration.ofMillis(1)).recoverWithItem(null), use: .ifNoItem().after(Duration.ofMillis(1).fail() which will propagate the failure.

You need to add the io.quarkus:quarkus-vertx dependency to your POM to activate the Vertx extension. io.smallrye.reactive:smallrye-mutiny-vertx-web-client is an external dependency that does not activate any extension.