Javascript 正在创建Vertx JS事件总线连接，然后关闭

后台：使用Java端的Vertx 3.3.3核心和Web作为服务器，使用Vertx-Web-3.3.3-client.js作为客户端，使用sockjsclient1.1.2.js

问题：我在本地计算机或LAN上成功地从客户端连接到eventbus。当我通过代理时，wss eventbus连接被阻止（在Firefox中，我看到“Firefox无法建立到的连接”wss://...“在铬中我看到”WebSocket连接到wss://... 失败：WebSocket握手期间出错：意外响应代码：400“，然后我看到了”https://…/eventbus/../xhr_send？t=…加载资源失败：服务器响应状态代码为500”）。但是，onopen启动，我收到一些数据（连接降级为可接受的协议？）。紧接着，onclose触发，我失去了连接。我知道我正在成功地到达Java vertx服务器，因为我的静态web和API调用正在工作

问题：我已经详细阅读了Vertx和SockJS文档。是否有：

关于vertx如何在JS Eventbus连接中尝试不同传输协议的文档

JS Vertex Eventbus通过业务代理工作的示例

实现Eventbus连接的另一种方法，可能是指定要尝试/使用的SockJS协议？（我正在尝试创建Eventbus连接的最简单方法，如文档中的许多地方所示）

我需要在SockJS/Eventbus设置的Java端做些什么

提前感谢您的建议/帮助！

编辑1:为Java服务器和JavaScript web客户端添加以下代码。web端非常基本（以及失败的原因）。Java端使用Spring进行依赖项注入和应用程序配置，具有一个Eventbus连接、一个API调用，并提供静态web内容

客户端到服务器的API调用工作正常，服务器正确地获取web内容，因此访问该工具是可行的。然而，代理导致wss失败（如预期的那样），但降级到xhr流媒体失败（我认为）

Javascript:

var EB;
var URL;
var APICall = "api/eventbus/publish/";
var IncomingAddress = "heartbeat-test";
var OutgoingAddress = "client-test";

function createConnection(){
    URL = $("#serveraddressinput").val(); //Getting url from html text box
    console.log("Creating Eventbus connection at " + URL + "eventbus"); //Eventbus address is '<link>/eventbus'
    EB = new EventBus(URL + "eventbus");

    testAPICall();

    EB.onopen = function(){
        console.log("Eventbus connection successfully made at " + URL + "eventbus");
        console.log("Registering Eventbus handler for messages at " + IncomingAddress);

        EB.registerHandler(IncomingAddress, function(error, message){
            console.log("Received Eventbus message " + JSON.stringify(message));
    };

    EB.onclose = function(){
        console.log("Eventbus connection at " + URL + " has been lost");
        URL = "";
    };
}

function testAPICall(){
    var link = URL + APICall + "heartbeat-test";
    console.log("Testing API call to " + link);
    $.ajax({
        url: link,
        type: 'POST',
        data: JSON.stringify({"testFromClient": "Test message sent from Client via API Call"}),
        dataType: 'json',
        success: function (data, textStatus) {
            console.log("API Call Success: " + JSON.stringify(data));
        },
        error: function (request, error) {
            console.log("API Call ERROR: " + JSON.stringify(request) + " " + error);
        }
    });
}

function sendTestMessage(){
    console.log("Sending test message to address " + OutgoingAddress);
    EB.send(OutgoingAddress, "Testing 1, 2, 3...");
}

var-EB；
var-URL；
var APICall=“api/eventbus/publish/”；
var IncomingAddress=“心跳测试”；
var OutgoingAddress=“客户测试”；
函数createConnection（）{
URL=$（“#服务器地址输入”）.val（）；//从html文本框获取URL
console.log（“在“+URL+”Eventbus”处创建Eventbus连接”）；//Eventbus地址为“/Eventbus”
EB=新的事件总线（URL+“事件总线”）；
testAPICall（）；
EB.onopen=函数（）{
log（“在“+URL+”Eventbus上成功建立了Eventbus连接”）；
log（“为“+IncomingAddress”处的消息注册Eventbus处理程序）；
EB.寄存器句柄（输入地址、函数（错误、消息）{
log（“接收到的事件总线消息”+JSON.stringify（消息））；
};
EB.onclose=函数（）{
log（“在“+URL+”处的Eventbus连接已丢失”）；
URL=“”；
};
}
函数testAPICall（）{
var link=URL+APICall+“心跳测试”；
log（“测试对“+链接”的API调用）；
$.ajax({
网址：link，
键入：“POST”，
数据：JSON.stringify（{“testFromClient”：“通过API调用从客户端发送的测试消息”}），
数据类型：“json”，
成功：功能（数据、文本状态）{
log（“API调用成功：+JSON.stringify（数据））；
},
错误：函数（请求、错误）{
log（“API调用错误：+JSON.stringify（请求）++”+ERROR）；
}
});
}
函数sendTestMessage（）{
console.log（“将测试消息发送到地址”+OutgoingAddress）；
EB.发送（支出地址，“测试1、2、3…”）；
}

爪哇：

。。。
导入io.vertx.core.AbstractVerticle；
导入io.vertx.core.Future；
导入io.vertx.core.eventbus.eventbus；
导入io.vertx.core.http.HttpMethod；
导入io.vertx.core.http.HttpServerOptions；
导入io.vertx.core.json.json；
导入io.vertx.core.json.JsonObject；
导入io.vertx.core.net.JKSOPTION；
导入io.vertx.ext.web.Router；
导入io.vertx.ext.web.RoutingContext；
导入io.vertx.ext.web.handler.BodyHandler；
导入io.vertx.ext.web.handler.CorsHandler；
导入io.vertx.ext.web.handler.StaticHandler；
导入io.vertx.ext.web.handler.sockjs.BridgeEvent；
导入io.vertx.ext.web.handler.sockjs.BridgeEventType；
导入io.vertx.ext.web.handler.sockjs.BridgeOptions；
导入io.vertx.ext.web.handler.sockjs.permitedoptions；
导入io.vertx.ext.web.handler.sockjs.SockJSHandler；
导入org.apache.logging.log4j.Level；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入org.slf4j.Marker；
导入org.slf4j.MarkerFactory；
导入org.springframework.beans.factory.annotation.Value；
导入org.springframework.stereotype.Service；
@服务
公共类MyTestVerticle扩展了AbstractVerticle{
私有最终静态记录器log=LoggerFactory.getLogger（MyTestVerticle.class）；
最终访问级别=Level.forName（“访问”，450）；
私有布尔启动；
专用int端口；
@值（${webserver.testpath.enabled}”）
启用私有布尔测试路径；
@值（${webserver.urlpath.test}”）
私有字符串testUrlPath；
@值（${webserver.filepath.test}”）
私有字符串testFilePath；
@值（${webserver.caching.enabled}”）
私有布尔运算；
@值（${webserver.ssl.enabled}）
私有布尔sslEnabled；
私人桥梁期权；
私有SockJSHandler-SockJSHandler；
专用路由器；
私人JksOptions sslKeyStoreOptions；
私人JksOptions SSLTrustStore选项；
公共MyTestVerticle（）{
this.start=false；
}
@凌驾
public void start（Future fut）引发异常{
info（“start（）--使用eventbus、API处理程序和
...

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.json.Json;
import io.vertx.core.json.JsonObject;
import io.vertx.core.net.JksOptions;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.ext.web.handler.CorsHandler;
import io.vertx.ext.web.handler.StaticHandler;
import io.vertx.ext.web.handler.sockjs.BridgeEvent;
import io.vertx.ext.web.handler.sockjs.BridgeEventType;
import io.vertx.ext.web.handler.sockjs.BridgeOptions;
import io.vertx.ext.web.handler.sockjs.PermittedOptions;
import io.vertx.ext.web.handler.sockjs.SockJSHandler;
import org.apache.logging.log4j.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class MyTestVerticle extends AbstractVerticle {

    private final static Logger log = LoggerFactory.getLogger(MyTestVerticle.class);

    final Level ACCESS = Level.forName("ACCESS", 450);

    private boolean started;

    private int port;

    @Value("${webserver.testpath.enabled}")
    private boolean testPathEnabled;

    @Value("${webserver.urlpath.test}")
    private String testUrlPath;

    @Value("${webserver.filepath.test}")
    private String testFilePath;

    @Value("${webserver.caching.enabled}")
    private boolean cachingEnabled;

    @Value("${webserver.ssl.enabled}")
    private boolean sslEnabled;

    private BridgeOptions bridgeOptions;

    private SockJSHandler sockJsHandler;

    private Router router;

    private JksOptions sslKeyStoreOptions;

    private JksOptions sslTrustStoreOptions;

    public MyTestVerticle() {
        this.started = false;
    }

    @Override
    public void start(Future<Void> fut) throws Exception {
        log.info("start() -- starting Vertx Verticle with eventbus, API handler, and static file handler");

        // grab the router
        router = getRouter();

        // enable CORS for the router 
        CorsHandler corsHandler = CorsHandler.create("*");  //Wildcard(*) not allowed if allowCredentials is true
        corsHandler.allowedMethod(HttpMethod.OPTIONS);
        corsHandler.allowedMethod(HttpMethod.GET);
        corsHandler.allowedMethod(HttpMethod.POST);
        corsHandler.allowedMethod(HttpMethod.PUT);
        corsHandler.allowedMethod(HttpMethod.DELETE);
        corsHandler.allowCredentials(false);
        corsHandler.allowedHeader("Access-Control-Request-Method");
        corsHandler.allowedHeader("Access-Control-Allow-Method");
        corsHandler.allowedHeader("Access-Control-Allow-Credentials");
        corsHandler.allowedHeader("Access-Control-Allow-Origin");
        corsHandler.allowedHeader("Access-Control-Allow-Headers");
        corsHandler.allowedHeader("Content-Type");

        // enable handling of body
        router.route().handler(BodyHandler.create());
        router.route().handler(corsHandler);
        router.route().handler(this::handleAccessLogging);

        // publish a payload to provided eventbus destination
        router.post("/api/eventbus/publish/:destination").handler(this::publish);

        // open up all for outbound and inbound traffic
        bridgeOptions = new BridgeOptions();
        bridgeOptions.addOutboundPermitted(new PermittedOptions().setAddressRegex(".*"));
        bridgeOptions.addInboundPermitted(new PermittedOptions().setAddressRegex(".*"));
//        sockJsHandler = SockJSHandler.create(vertx).bridge(bridgeOptions);   
         sockJsHandler = SockJSHandler.create(vertx);
         sockJsHandler.bridge(bridgeOptions, be -> {
            try {
                if (be.type() == BridgeEventType.SOCKET_CREATED) {
                    handleSocketOpenEvent(be);
                }
                else if(be.type() ==BridgeEventType.REGISTER) {
                    handleRegisterEvent(be);
                }
                else if(be.type() ==BridgeEventType.UNREGISTER) {
                    handleUnregisterEvent(be);
                }
                else if(be.type() ==BridgeEventType.SOCKET_CLOSED) {
                    handleSocketCloseEvent(be);
                }
            } catch (Exception e) {

            } finally {
                be.complete(true);
            }
        });
        router.route("/eventbus/*").handler(sockJsHandler);

        if(testPathEnabled){
            router.route("/" + testUrlPath + "/*").handler(StaticHandler.create(testFilePath).setCachingEnabled(cachingEnabled));
        }

        // create periodic task, pushing all current EventBusRegistrations
        vertx.setPeriodic(1000, handler -> {
            JsonObject obj =new JsonObject();
            obj.put("testMessage", "Periodic test message from server...");
            vertx.eventBus().publish("heartbeat-test", Json.encodePrettily(obj));
        });

        EventBus eb = vertx.eventBus();
        eb.consumer("client-test", message -> {
            log.info("Received message from client: " + Json.encodePrettily(message.body()) + " at " + System.currentTimeMillis());
        });

        HttpServerOptions httpOptions = new HttpServerOptions();
        if(sslEnabled){
                httpOptions.setSsl(true);
                httpOptions.setKeyStoreOptions(sslKeyStoreOptions);
        }

        log.info("starting web server on port: " + port);
        vertx
                .createHttpServer(httpOptions)
                .requestHandler(router::accept).listen(
                port,
                result -> {
                    if (result.succeeded()) {
                        setStarted(true);
                        log.info("Server started and ready to accept requests");
                        fut.complete();
                    } else {
                        setStarted(false);
                        fut.fail(result.cause());
                    }
                }
        );
    }

    private void handleSocketOpenEvent(BridgeEvent be){
        String host =be.socket().remoteAddress().toString();
        String localAddress = be.socket().localAddress().toString();
        log.info("Socket connection opened! Host: " + host + " Local address: " + localAddress);
    }

    private void handleRegisterEvent(BridgeEvent be){
        String host =be.socket().remoteAddress().toString();
        String localAddress = be.socket().localAddress().toString();
        String address = be.getRawMessage().getString("address").trim();
        log.info("Eventbus register event! Address: " + address + " Host: " + host + " Local address: " + localAddress);
    }

    private void handleUnregisterEvent(BridgeEvent be){
        String host =be.socket().remoteAddress().toString();
        String localAddress = be.socket().localAddress().toString();
        String address = be.getRawMessage().getString("address").trim();
        log.info("Eventbus unregister event! Address: " + address + " Host: " + host + " Local address: " + localAddress);
    }

    private void handleSocketCloseEvent(BridgeEvent be){
        String host =be.socket().remoteAddress().toString();
        String localAddress = be.socket().localAddress().toString();
        log.info("Socket connection closed! Host: " + host + " Local address: " + localAddress);
    }

    //Method handles logging at custom level for access logging to files
    private void handleAccessLogging(RoutingContext routingContext){
        Marker accessMarker = MarkerFactory.getMarker("ACCESS");

        if(routingContext.normalisedPath().contains("/api")){
            log.info(accessMarker, "Api access log: request= " + routingContext.normalisedPath() + " source=" + routingContext.request().remoteAddress());
        }
        else{
            log.info(accessMarker, "Web access log: path= " + routingContext.normalisedPath() + " source= " + routingContext.request().remoteAddress());
        }

        routingContext.next();
    }

    /**
     * Accept a payload (anything) and publish to the provided destination
     *
     * @param routingContext
     */
    private void publish(RoutingContext routingContext) {
        String destination = routingContext.request().getParam("destination");
        String payload = routingContext.getBodyAsString();
        if ((destination == null) || (payload == null)) {
            Exception e = new Exception("Missing arguments");
            routingContext.response().setStatusCode(406);
            routingContext.fail(e);
        } else {
            log.info("API Call -> Publishing to destination: " + destination + " payload: " + payload);
            vertx.eventBus().publish(destination, payload);
            routingContext
                    .response()
                    .setStatusCode(200)
                    .putHeader("content-type", "application/json; charset=utf-8")
                    .end(payload);
        }
    }

    public boolean isStarted() {
        return started;
    }

    public void setStarted(boolean started) {
        this.started = started;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public Router getRouter(){
        if(router == null){
            router = Router.router(vertx);
        }
        return router;
    }

    public void setRouter(Router router){
        this.router = router;
    }

    public void setSslOptions(JksOptions keyStoreOptions, JksOptions trustStoreOptions) {
        this.sslKeyStoreOptions = keyStoreOptions;
        this.sslTrustStoreOptions = trustStoreOptions;
    }
}

...
router.route("/eventbus/*").handler(sockJsHandler);
...
// enable handling of body
router.route().handler(BodyHandler.create());
router.route().handler(corsHandler);
router.route().handler(this::handleAccessLogging);

// publish a payload to provided eventbus destination
router.post("/api/eventbus/publish/:destination").handler(this::publish);