Java how to Uni.createFrom().future() and return that Uni from the enclosing method?

Question

I am very new to Java and Mutiny.

As indicated below, my test function asks Redis for the value of key "foo" which is "bar". That is working and the Future onCompleted() gets "bar".

So far so good.

I have two issues with the Uni.createFrom().future() bit.

1. The compiler says: The method future(Future<? extends T>) in the type UniCreate is not applicable for the arguments (Future<Response>). I have tried the suggested fixes but ended up in a deeper hole. My Java skills are insufficient to fully grasp the meaning of the error.

2. How do I get "bar" into the Uni<String> returned from test()? I have tried all sorts of subscribing and CompletableFutures and cannot make anything work. I figure I need to return a function to generate the Uni but am at a loss about how to do that.

// The abbreviated setup
import io.vertx.redis.client.Redis;
private final Redis redisClient;
this.redisClient = Redis.createClient(vertx);


public Uni<String> test () {
  // Ask Redis for the value of key "foo" => "bar"
  Future<Response> futureResponse = this.redisClient.send(Request.cmd(Command.create("JSON.GET")).arg("foo"))
      .compose(response -> {
        // response == 'bar'
        return Future.succeededFuture(response);
      }).onComplete(res -> {
        // res == 'bar'
      });

  // How to make the return of the Uni<String> wait for the completed futureResponse 
  // so it makes a Uni<String> from "bar" and returns it from the method?
  Uni<String> respUni = Uni.createFrom().future(futureResponse);

  return respUni;
}

Thanks. Any suggestions gratefully accepted! (And yes, I have spent many hours trying to work it out for myself) ;-)

Answer 1

Updated the post, because of errors.

UniCreate.future() takes a java.util.concurrent.Future of some type and returns Uni of the same type. That is, you'll have to pass a java.util.concurrent.Future<String> to get a Uni<String>.

The send method of the Redis client returns a io.vertx.core.Future<Response> which is not assignment compatible to java.util.concurrent.Future.

Fortunately, the API provides io.vertx.core.Future#toCompletionStage to convert a vertx Future to a JDK CompletionStage while Mutiny provides UniCreate.completionStage() to get the job done.

public Uni<String> test () {
  Future<String> futureResponse = this.redisClient.send(Request.cmd(Command.create("JSON.GET")).arg("foo"))
      .compose(response -> {
        return Future.succeededFuture(response.toString());
      });

  Uni<String> respUni = Uni.createFrom().completionStage(futureResponse.toCompletionStage());

  return respUni;
}