Java 如何响应来自eventbus使用者的http请求

更改： 如何从套接字响应http请求。 网络代码：

public void start() {
    Router router = Router.router(vertx);
    router.route("/api/getdata").handler(this::getData);
    vertx.createHttpServer().requestHandler(router::accept).listen(8080);
}

private void getData(RoutingContext routingContext) {
    vertx.eventBus().send(ServerVerticle.ADDRESS, pricemessage, reply -> {

    });
}

套接字代码：

public void start() {
    final EventBus eb = vertx.eventBus();
    NetClient netClient = vertx.createNetClient();
    if (ar.succeeded()) {
        socket.handler(this::onDataReceived);
        eb.consumer(ServerVerticle.ADDRESS, message -> {
            socket.write(buffer);   // request from the getData method
            message.reply(data);// no data here, it's in the handler
        }
    }
}

private void onDataReceived(Buffer buffer) {
    // buffer changed to JsonObject here
    vertx.eventBus().send("some address here", jsonObject);
}

套接字处理程序没有返回值。只是一个事件巴士发送。 我不知道如何将这个jsonObject响应到http请求

public void start() {
    Router router = Router.router(vertx);
    router.route(API_GET).handler(this::getData);

    vertx.eventBus().consumer(ADDRESSHERE, msg -> {
        // get data from the socket send.    2
    });
         vertx.createHttpServer().requestHandler(router::accept).listen(8080, result -> {

        });
}

private void getData(RoutingContext routingContext) {
    vertx.eventBus().send(ADDRESS, message); // send message to the top // 1 verticle

// 3 
}

========================================================================

老问题，也许不清楚。 我有一个顶点来处理套接字写入和响应

public void start() {   // 1
    NetClient netClient = vertx.createNetClient();
    netClient.connect(port, host, ar -> {
        socket = ar.result(); // NetSocket
        socket.handler(this::doSocketHandleMethod);
        socket.write(BYTEBUFFER);// buffer here
    })
}

private void doSocketHandleMethod(Buffer buffer){ // socket handler 
    // process data here and send
    vertx.eventBus().send(ADDRESS, data here);
}

我使用下面的代码从http请求获取响应

public void start() {
    Router router = Router.router(vertx);
    router.route(API_GET).handler(this::getData);

    vertx.eventBus().consumer(ADDRESSHERE, msg -> {
        // get data from the socket send.    2
    });
         vertx.createHttpServer().requestHandler(router::accept).listen(8080, result -> {

        });
}

private void getData(RoutingContext routingContext) {
    vertx.eventBus().send(ADDRESS, message); // send message to the top // 1 verticle

// 3 
}

问题是上面提到的第二个代码获取数据，但不确定如何从http REQUEST 3获取响应。

将（HttpServerRequest）传递到路由（

requestHandler（router:：accept）

）并包含在RoutingContext中。“当服务器接收HTTP请求时，[…]的实例。HttpServerRequest将被创建并传递给此处理程序。”-JavaDoc

因此，如果数据到达2，并且您想要对HttpServerRequest进行响应（作为第三步），那么您可以在

getData（）

方法中使用

routingContext.response（）

，以获得HttpServerResponse

---

如果要处理http服务器请求，请向从套接字获取某些数据的使用者发送消息，并将此结果作为对特定http服务器请求的答复发送，然后可以执行以下操作：

// Send a message and get the response via handler
private void getData(RoutingContext routingContext) {
vertx.eventBus().send(ADDRESS, message, handler -> {
  if(handler.succeded()) {
    routingContext.response().end(handler.result());
  }
  else {
    // error
  }
});
}

// To reply to a message do
vertx.eventBus().consumer(ADDRESSHERE, msg -> {
    // get data from the socket send.    2
  msg.reply(data); // you can only do a reply once. Put data into reply
});

---

据我所知，事件总线只知道“发送和回复”，而不是像套接字这样的概念。看起来您希望在每次通过套接字获得新数据时发送数据

您可以多次向httpResponse写入内容，因此需要保存对响应对象的引用

但我不知道，这是否是一个好主意。我建议封装套接字获取数据过程。“socket”垂直图只回答一次，它有整个缓冲区。这里有两个例子来说明我的意思

// open socket
vertx.eventBus().consumer("ADRRESS", message -> {
  // execute this on worker thread to not block the event bus thread
  vertx.executeBlocking(future -> {
    Buffer buffer = Buffer.buffer();
    socket.handler(buff -> buffer.appendBuffer(buff)) // read data
    .endHandler(endHandler -> {
      // no more data to read
      socket.pause();
      future.complete(buffer);
    })
    .resume() // socket was paused, now read the data
    .exceptionHandler(err -> future.fail(err)); // handle exception
  }, result -> {
    if(result.succeeded()) {
      message.reply(result.result()); // reply with the buffer content
    }
    else {
      message.reply(result.cause()); // may want to send error later
    }
  });
});

// connect and get a new socket every time
vertx.eventBus().consumer("ADRRESS", message -> {
  // execute this on worker thread to not block the event bus thread
  vertx.executeBlocking(future -> {
    netClient.connect(1, "", netSocketHandler -> {
      if(netSocketHandler.succeeded()) {
        Buffer buffer = Buffer.buffer();
        netSocketHandler.result().handler(buff -> buffer.appendBuffer(buff)) // read data
        .endHandler(endHandler -> {
          // no more data to read
          future.complete(buffer);
          netSocketHandler.result().close(); // close the NetSocket once finished
        })
        .exceptionHandler(err -> {
          netSocketHandler.result().close();
          future.fail(err);
        }); // handle exceptions
      }
      else {
        future.fail(netSocketHandler.cause());
      }
    });
  }, result -> {
    if(result.succeeded()) {
      message.reply(result.result()); // reply with the buffer content
    }
    else {
      message.reply(result.cause()); // may want to send error later
    }
  });
});

---

如果这对您没有帮助，我很抱歉，也许这不是您要寻找的概念。

但是得到一个HttpServerResponse，那么数据就在vertx.eventBus（）.consumer中。这个问题的要点是：如何响应来自eventbus消费者的http请求。@lanjingyu，你不应该这样做。消费者的整个想法是，他们不知道如何使用他们的响应。是的，但问题是当从套接字获取数据时，没有返回值。套接字也使用处理程序，并且该处理程序仍然使用eventbus.send。这里的代码是：socket.write（缓冲区）；handler（this:：receiveData）

vertx.eventBus（）.consumer（ADDRESSHERE，msg->{socket.write（buffer）；//此处无数据msg.reply（data）；}）；handler（this:：receivedata）；ReceiveData函数{eventbus.send（）；}

所以我想可能需要一个桥接器或sockjs之类的东西。我正在努力。