Question

我有两个操作step_1（）和step_2（），并希望在step_1（）之后执行step_2（）。

使用普通的java，这将是：

step_1();
step_2();

使用vertx我必须使用vertx-compose（）。我是对的吗？

根据https://groups.google.com/forum/#!topic/vertx/FuvlPLpoGOA，我不需要Futures来获得顺序代码。

“如果您想按顺序执行每个请求，则不需要期货。”

那么如果不使用期货我怎么能这样做呢？

我不知道，如果这很重要：我执行此代码的Vertx是一个“工人”-Verticle。

@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_1（）和step_1（）都没有设计为返回结果（即它们有效地返回 void ），那么您可以将它们更改为返回Observable或Single并将它们链接在一起，类似于此：

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

RxJava（或者更确切地说，反应式编程）需要一点点来解决它，但如果您打算将异步操作链接在一起，我强烈建议您使用它。

Answer 2

以下是module.exports = { entry: "./Scripts/hello-stackoverflow/index.tsx", output: { filename: "./dist/bundle.js" }, // Enable sourcemaps for debugging webpack's output. devtool: "source-map", resolve: { // Add '.ts' and '.tsx' as resolvable extensions. extensions: [".ts", ".tsx", ".js", ".json"] }, module: { rules: [ // All files with a '.ts' or '.tsx' extension will be handled by 'awesome-typescript-loader'. { test: /\.tsx?$/, loader: "ts-loader" }, // All output '.js' files will have any sourcemaps re-processed by 'source-map-loader'. { enforce: "pre", test: /\.js$/, loader: "source-map-loader" } ] }, externals: { "react": "React", "react-dom": "ReactDOM" }的链接示例，尽管如此，我已经将这个例子展示得非常简单。

import React,{Component} from 'react';
import { BrowserRouter as Router, Route, Link } from 'react-router-dom';

class App extends Component{

    render(){
      return(
        <Link to="/signin"><input value="profile"/></Link>
           );
    }

}

export default App;

Answer 3

＆＃34;如果你想按顺序完成每个请求，你就不需要期货。＆＃34;

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

使用期货查看此code，使用RxJava 2 newer version和article查看项目。

@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 4

将step_2作为参数传递给step_1

@Override
public void start(Future<Void> fut) throws IOException {
    step_1(step_2);
}

private void step_1(Runnable function){
    someAsynccall("some-arg", response -> {
        function.run();
    }).end();
}

private void step_2(){
    // do something
}

用vertx编写顺序代码

4 个答案: