Vertx - Future.compose

1.vertx中的Future与java原生中不同,二者都有封装结果的功能,但是vertx中为了避免await阻塞event loop线程,导致不能及时响应的问题.通过在Future中定义回调Handler来解决这个问题.
demo1:

    private static void asynchronousMethod(Future<String> f){
        f.complete("haha");
    }
    
    public static void main(String[] args) {    
        Future<String> future = Future.future();
        future.setHandler(r -> {
            System.out.println("result is:" + r);
        });
        asynchronousMethod(future); 
    }

demo1解释:
1.定义一个结果类型为String的Future.
2.为这个Future设置回调.
3.调用异步方法,将这个Future作为参数传入
4.complete()将调用结果封装进Future,并将Future的状态置为completed.返回.
5.最后回调函数执行,处理调用结果.

需要理清的是,
Future<T> 中的T代表的是返回的结果类型.
Handler<AsyncResult<T>> 是对调用结果的处理函数.

2.理解compose,compose是为了应对回调地狱采用的链式写法.
compose的第一种写法:

  default <U> Future<U> compose(Handler<T> handler, Future<U> next) {
    setHandler(ar -> {
      if (ar.succeeded()) {
        try {
          handler.handle(ar.result());
        } catch (Throwable err) {
          if (next.isComplete()) {
            throw err;
          }
          next.fail(err);
        }
      } else {
        next.fail(ar.cause());
      }
    });
    return next;
  }

传入参数为
1.调用此compose方法的future的handler,
2.下一个future

处理思路:
1.执行compose调用future的回调处理
2.如果当前future的回调处理中出错,那么将下一个future置为失败,
3.未出错则直接将下一个future返回.
demo2:

        Future<String> f1 = Future.future();
        Future<Integer> f2 = Future.future();

        f1.complete("f1's result");

        f1.compose(r -> {
            System.out.println("f1 handler:" + r);
            f2.complete(123);
        } , f2).setHandler(r -> {
            System.out.println("f2 handler:" + r.result());
        });

demo2解释:
1.定义2个future
2.第4行模拟第1个异步调用完毕,f1得到结果,状态completed.
3.f1发起compose,参数1为f1的handler,参数2为下一个future f2
4.注意,在f1的handler中,模拟第2个异步调用完毕,f2状态转为completed,从而触发f2的handler.

compose的第2种写法

  default <U> Future<U> compose(Function<T, Future<U>> mapper) {
    if (mapper == null) {
      throw new NullPointerException();
    }
    Future<U> ret = Future.future();
    setHandler(ar -> {
      if (ar.succeeded()) {
        Future<U> apply;
        try {
          apply = mapper.apply(ar.result());
        } catch (Throwable e) {
          ret.fail(e);
          return;
        }
        apply.setHandler(ret);
      } else {
        ret.fail(ar.cause());
      }
    });
    return ret;
  }

处理思路:
1.传入参数类型Function<T, Future<U>>,说明传入的是一个转换函数,此函数将future中的调用结果T转换为链中的下一个future.
2.如果调用是成功的,那么将调用结果作为参数传入这个function执行,就是这句"apply = mapper.apply(ar.result());",返回结果为Future<U>.
3.由于事先需要对调用结果ar是否成功判断,所以外面再套了个Future<U> ret.
4.将ret返回.
这个封装蛮有意思,在compose方法中设置调用者future的handler,在handler中将future中的结果ar传递给compose参数(function),然后执行function,最后将function返回的future用compose内部生成的future封装下返回.
demo3:

        Future<String> f1 = Future.future();
        f1.complete("f1's result");
        
        f1.compose(r -> {
            System.out.println(r);
            Future<String> f2 = Future.future();
            f2.complete("f2's result");
            return f2;
        }).compose(r -> {
            System.out.println(r);
            Future<String> f3 = Future.future();
            f3.complete("f3's result");
            return f3;
        }).setHandler(r -> {
            System.out.println(r.result());
        });

虽然api封装复杂了些,但是使用过程比第1种写法更加简单了.也容易理解.