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>>什么鬼？

@FunctionalInterfacepublic 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过去，都可以传啊，这样多个异步操作就灵活多了。