vert.x:compose

自从有了callback hell，妈妈再也不用担心我的compose了！！！

如题，都懂的。先看vert.x里compose的源码

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

                next.fail(var4);
            }
        } else {
            next.fail(ar.cause());
        }

    });
    return next;
}

也就是说，它拿着一个异步操作的结果，进行下一步的操作，异步异常返回到next里。

没有看到next的complete()啊，是的啊，这样你就可以拿着这个next一直compose链下去，直到你调用next.complete()这才算完。

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

                apply.setHandler(ret);
            } else {
                ret.fail(ar.cause());
            }

        });
        return ret;
    }
}

那Function<T, Future<R>>什么鬼？

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

好的，就是

compose( t -> {

return new Future<R>

})

类似这样吧！

说了那么多还不如上（伪）代码

Future<Object> fut = Future.future();

asynchronizedOption1.compose(asynOptionResult1 -() {

   XXX(拿着异步操作结果做事)XXX

// 如果做完就返回则把next.complete掉就行了

next.complete(SomeValue);

                }, fut);

如果还有后续操作，则可以在其后连接

fut.compose(value1-> {

  }).compose(vaule2->{

  }).compose(value3->{

       Future<Void> endFut = Future.future();

      XXX(拿着异步操作结果做事)XXX

  }, endFut);

还有一点值得注意：在handler中生成一个新的Future然后可以选择一个下一个异步需要的参数传递过去（上一步的结果传到下一步），

     也可以传一个Map过去，都可以传啊，这样多个异步操作就灵活多了。