JarCastingvertx-async
vertx-async is a Vert.x module that provides helper methods for common async patterns. It helps avoid call back hell and is inspired by the API of the popular async node.js module.
Using
The module is available on Maven Central:
<dependency>
<groupId>org.simondean.vertx</groupId>
<artifactId>vertx-async</artifactId>
<version>0.1.1</version>
<scope>provided</scope>
</dependency>
The module then needs to be added to the includes field of your mod.json:
"includes": "org.simondean.vertx~vertx-async~0.1.6"
The patterns are all available as static methods on the org.simondean.vertx.async.Async class.
Patterns
Series
public void seriesExample(AsyncResultHandler<List<String>> handler) {
Async.<String>series()
.task(taskHandler -> {
String result = getSomeResult();
taskHandler.handle(DefaultAsyncResult.succeed(result));
})
.task(taskHandler -> {
someAsyncMethodThatTakesAHandler(taskHandler);
})
.run(result -> {
if (result.failed()) {
handler.handle(DefaultAsyncResult.fail(result.cause()));
return;
}
List<String> resultList = result.result();
doSomethingWithTheResults(resultList);
handler.handle(DefaultAsyncResult.succeed(resultList));
});
}
Waterfall
public void waterfallExample(AsyncResultHandler<Integer> handler) {
Async.waterfall()
.<String>task(taskHandler -> {
String result = getSomeResult();
taskHandler.handle(DefaultAsyncResult.succeed(result));
})
.<Integer>task((result, taskHandler) -> {
someAsyncMethodThatTakesAResultAndHandler(result, taskHandler);
})
.run(result -> {
if (result.failed()) {
handler.handle(DefaultAsyncResult.fail(result.cause()));
return;
}
Integer resultValue = result.result();
doSomethingWithTheResults(resultValue);
handler.handle(DefaultAsyncResult.succeed(resultValue));
});
}
Each
public void eachExample(AsyncResultHandler<Void> handler) {
List<String> list = Arrays.asList("one", "two", "three");
Async.iterable(list)
.each((item, eachHandler) -> {
doSomethingWithItem(item, eachHandler);
})
.run(vertx, handler);
}
Retry
public void retryExample(AsyncResultHandler<String> handler) {
Async.retry()
.<String>task(taskHandler -> {
someAsyncMethodThatTakesAHandler(taskHandler);
})
.times(5)
.run(result -> {
if (result.failed()) {
handler.handle(DefaultAsyncResult.fail(result));
return;
}
String resultValue = result.result();
doSomethingWithTheResults(resultValue);
handler.handle(DefaultAsyncResult.succeed(resultValue));
});
}
Forever
public void foreverExample(AsyncResultHandler<String> handler) {
Async.forever()
.task(taskHandler -> {
someAsyncMethodThatTakesAHandler(taskHandler);
})
.run(vertx, result -> {
handler.handle(DefaultAsyncResult.fail(result));
});
}