群集顶点中的SockJS连接。x环境

Question

vertx应用程序在两个EC2实例上的Docker容器中运行，并且是集群的。

集群是通过hazelcast aws插件实现的，应用程序的启动如下：

docker run --name ... -p ... \
--network ... \
-v ... \
-d ... \
-c 'exec java \
-Dvertx.eventBus.options.setClustered=true \
-Dvertx.eventBus.options.setClusterPort=15701 \
-jar ... -conf ... \
-cluster'

没有以编程方式设置任何与群集相关的内容。

客户端在第一个请求上打开一个套接字并将其用于未来的类似请求。
每个请求将：

1. 通过向事件总线发布消息来启动与服务器的异步请求
2. 在事件总线上注册一个使用者，该事件总线将处理上述结果，并将引用传递给它应该将结果发送到的套接字连接

由于vertx在集群时默认进行循环，并且有两个实例，这意味着任何实例都会获得其他消息（来自上面的1），并使仅连接到一个实例的客户端接收到所有预期响应的一半。

我想这是因为，即使注册的使用者有一个对套接字对象的引用，它也不能使用它，因为它是在不同的节点/Web服务器上创建的。

这是正确的吗？有没有一种方法可以将100%的消息发送到客户端，只连接到一个节点，而不引入RabbitMQ之类的东西？

这是SockJS处理程序代码：

SockJSHandler sockJSHandler = SockJSHandler.create(vertx, new SockJSHandlerOptions());
sockJSHandler.socketHandler(socket -> {
    SecurityService securityService = (SecurityService) ServiceFactory.getService(SecurityService.class);
    if (securityService.socketHeadersSecurity(socket)) {
        socket.handler(socketMessage -> {
            try {
                LOGGER.trace("socketMessage: " + socketMessage);
                Socket socket = Json.decodeValue(socketMessage.toString(), Socket.class);
                Report report = socket.getReport();
                if (report != null) {
                    Account accountRequest = socket.getAccount();
                    Account accountDatabase = accountRequest == null ? null
                            : ((AccountService) ServiceFactory.getService(AccountService.class)).getById(accountRequest.getId());
                    Response result = securityService.socketReportSecurity(accountRequest, accountDatabase, report) ?
                            ((ReportService) ServiceFactory.getService(ReportService.class)).createOrUpdateReport(report, accountDatabase)
                            : new Response(Response.unauthorized);
                    if (Response.success.equals(result.getResponse())) {
                        //register a consumer
                        String consumerName = "report.result." + Timestamp.from(ClockFactory.getClock().instant());
                        vertx.eventBus().consumer(consumerName, message -> {
                            Response executionResult;
                            if ("success".equals(message.body())) {
                                try {
                                    Path csvFile = Paths.get(config.getString(Config.reportPath.getConfigName(), Config.reportPath.getDefaultValue())
                                            + "/" + ((Report) result.getPayload()).getId() + ".csv");
                                    executionResult = new Response(new JsonObject().put("csv", new String(Files.readAllBytes(csvFile))));
                                } catch (IOException ioEx) {
                                    executionResult = new Response(new Validator("Failed to read file.", ioEx.getMessage(), null, null));
                                    LOGGER.error("Failed to read file.", ioEx);
                                }
                            } else {
                                executionResult = new Response(new Validator("Report execution failed", (String)message.body(), null, null));
                            }
                            //send second message to client
                            socket.write(Json.encode(executionResult));
                            vertx.eventBus().consumer(consumerName).unregister();
                        });
                        //order report execution
                        vertx.eventBus().send("report.request", new JsonObject()
                                .put("reportId", ((Report) result.getPayload()).getId())
                                .put("consumerName", consumerName));
                    }
                    //send first message to client
                    socket.write(Json.encode(result));
                } else {
                    LOGGER.info("Insufficient data sent over socket: " + socketMessage.toString());
                    socket.end();
                }
            } catch (DecodeException dEx) {
                LOGGER.error("Error decoding message.", dEx);
                socket.end();
            }
        });
    } else {
        LOGGER.info("Illegal socket connection attempt from: " + socket.remoteAddress());
        socket.end();
    }
});
mainRouter.route("/html" target="_blank">websocket/*").handler(sockJSHandler);

有趣的是，当在localhost上运行两个集群节点时，客户端将获得100%的结果。

编辑：这不是SockJS，而是配置问题。

Answer 1

由于vertx在集群时默认进行循环，并且有两个实例，这意味着任何实例都会获得其他消息（来自上面的1），并使仅连接到一个实例的客户端接收到所有预期响应的一半。

这个假设只是部分正确。Vert. x确实循环，是的，但这意味着每个实例将获得一半的连接，而不是一半的消息。

一旦建立连接，其所有消息将到达单个实例。

因此：

这是正确的吗？有没有一种方法可以将100%的消息发送到客户端，只连接到一个节点，而不引入RabbitMQ之类的东西？

已经发生了。