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