VERTX JS Eventbus接続が閉じた後に作成されて

Question

背景：としてVERTXウェブ-3.3.3-client.jsを、サーバーなどのJava側の3.3.3コアとウェブVERTXを使用して使用して私が成功したときに私のローカルマシン上またはLANクライアントからeventbusへの接続を作っています：sockjsclient1.1.2.js

を発行してクライアント。私がプロキシを通過すると、wss eventbus接続がブロックされています（Firefoxでは「」と表示されます。Firefoxは「wss：// ...」への接続を確立できません）、クロムでは「wss ：// ...失敗：WebSocketハンドシェイク中にエラー：予期しない応答コード：400 "、" https：//.../eventbus/.../xhr_send？t = ...読み込みに失敗しましたリソース：サーバがステータスコード500で応答しました。）しかし、onopenが起動し、いくつかのデータ（接続は受け入れられたプロトコルにダウングレードされていますか？）を受け取りました。静的WebとAPI呼び出しが機能しているので、私はJavaの頂点サーバーに正常に到達していることがわかります

質問：私はVertxとSockJSのドキュメントを広く見てきました。そこには：

1. JS Eventbus接続でvertexがさまざまな転送プロトコルを試行する方法に関する文書はありますか？
2. ビジネスプロキシを使用しているJS Vertx Eventbusの例ですか？
3. Eventbus接続を実装するもう1つの方法は、おそらくSockJSプロトコルを試して使用することですか？ （私は、ドキュメントの多くの場所に示されているように、イベントバス接続を作成する最も簡単な方法を試しています）
4. SockJS/EventbusセットアップのJava側で何かする必要がありますか？

アドバイス/助けをお寄せいただきありがとうございます！

EDIT 1： JavaサーバーとJavaScriptの両方のWebクライアント側に次のコードを追加します。 Web側は非常に基本的です（何が失敗しているのか）。 Java側は、依存関係注入とアプリケーション設定にSpringを使用し、Eventbus接続と1つの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..."); 
} 

のJava：

... 

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; 
    } 
} 

Answer 1

このエラー

1. Javaバーチクルでは、イベントバスハンドラをtに移動しますopを他のハンドラの前に置いてください。私はBodyHandlerまたはCorsHandlerがそれを乱して500エラーを引き起こしていると思います。

   ... 
   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);