使用vertx编写顺序代码

Question

我有两个操作step\u 1（）和step\u 2（），希望在step\u 1（）之后执行step\u 2（）。

对于普通java，这将是：

step_1();
step_2();

对于vertx，我必须使用vertx-compose（）。我说得对吗？

根据https://groups.google.com/forum/#哦！topic/vertx/FuvlPLpoGOA，我不需要序列代码的未来。

“如果你想按顺序完成每个请求，你不需要未来。”

那么，如果不使用期货，我怎么能做到这一点呢？

我不知道这是否重要：执行此代码的Vertx是一个“Worker”垂直体。

@Override
public void start(Future<Void> fut) throws IOException {

Future<Void> step_1 = Future.future();
    step_1.compose(res -> {
        // If the future succeeded
        Future<Void> step_2 = step_1();

        step_2.compose(res2 -> {
            step_2();

        }, Future.future().setHandler(handler -> {
            // If the future failed
        }));

        //I dont need that
    }, Future.future().setHandler(handler -> {
        // If the future failed
    }));

}

public void step_1(){
..
}

public void step_2(){
..
}

这是最右边最短的（！）方法

Answer 1

RxJava专门用于编写异步事件：http://vertx.io/docs/vertx-rx/java/

假设step\u 1（）和step\u 1（）都不是为了返回结果而设计的（即，它们实际上返回void），那么您可以将它们更改为返回Observable或Single，并将它们链接在一起，类似于此：

step_1().doOnSuccess(this::step_2()).subscribe(/* control resumes here */);

RxJava（或者更确切地说，一般的反应式编程）需要一点时间才能理解它，但如果您计划将异步操作链接在一起，我强烈建议您使用它。

Answer 2

“如果你想按顺序完成每个请求，你不需要未来。”

不，不是。在像Vert. x这样的异步框架中，输入/输出操作是非阻塞的。这意味着，如果您调用几个异步操作，它们将同时开始工作。如果您想按顺序执行几个请求，那么您应该使用期货或回调仅在前一个成功完成后执行新请求。

请使用futures、RxJava 2的更新版本和关于项目的文章检查此代码。

@Override
public Future<Optional<Todo>> getCertain(String todoID) {
    Future<Optional<Todo>> result = Future.future();
    redis.hget(Constants.REDIS_TODO_KEY, todoID, res -> {
        if (res.succeeded()) {
            result.complete(Optional.ofNullable(
                res.result() == null ? null : new Todo(res.result())));
        } else
            result.fail(res.cause());
    });
    return result;
}

@Override
public Future<Todo> update(String todoId, Todo newTodo) {
    return this.getCertain(todoId).compose(old -> {
        if (old.isPresent()) {
            Todo fnTodo = old.get().merge(newTodo);
            return this.insert(fnTodo)
                .map(r -> r ? fnTodo : null);
        } else {
            return Future.succeededFuture();
        }
    });
}

Answer 3

下面是一个链接未来的例子，我把这个例子做得很简单，但它展示了这个概念。

@RunWith(VertxUnitRunner.class)
public class Chaining {
    private Vertx vertx = Vertx.vertx();

    @Test
    public void futures_chaining(TestContext context) throws Exception {
        Async async = context.async();

        firstOperation()
                .compose((outcome) -> {
                    System.out.println(outcome);

                    return secondOperation();
                })
                .compose(outcome -> {
                    System.out.println(outcome);

                    /*
                      For stopping unit test we are returning this future                                                                                                                                                              
                      for production use-case this would be Future.succeededFuture 
                      or Future.failedFuture depending on your method outcomes
                     */
                    return Future.future(handle -> async.complete());
                });
    }

    private Future<String> firstOperation() {
        Future<String> future = Future.future();

        vertx.setTimer(1000, delay -> future.complete("First Operation Complete"));

        return future;
    }

    private Future<String> secondOperation() {
        Future<String> future = Future.future();

        vertx.setTimer(1000, delay -> future.complete("Second Operation Complete"));

        return future;
    }
}