Vert.x WebSocket返回200而不是101

Question

I'm trying to set up a basic HTTP and WebSocket Vert.x server, but the WebSocket route is always returning a 200 instead of a 101.

public class PhilTheServer extends AbstractVerticle {

    private final static int PORT = 8080;

    @Override
    public void start(Future<Void> fut) {
        // Create a router object.
        Router router = Router.router(vertx);

        // We need cookies, sessions and request bodies
        router.route().handler(CookieHandler.create());
        router.route().handler(BodyHandler.create());

        router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));

        // Simple auth service which uses a properties file for user/role info
        AuthProvider authProvider = ShiroAuth.create(vertx, new ShiroAuthOptions()
                .setType(ShiroAuthRealmType.PROPERTIES)
                .setConfig(new JsonObject()
                    .put("properties_path", "src/main/resources/vertx-users.properties")));

        // We need a user session handler too to make sure the user is stored in the session between requests
        router.route().handler(UserSessionHandler.create(authProvider));

        // Serve the static private pages from directory "webroot"
        router.route("/static/*").handler(StaticHandler.create("webroot/static").setCachingEnabled(false));

        // Public Index Page
        router.get("/").handler(ctx -> {
            ctx.response().sendFile("webroot/index.html");
        });

        router.mountSubRouter("/api", APIRoutes.get(vertx, authProvider));

        // Default non-handled requests:
        router.route().handler(ctx -> {
            ctx.fail(404);
        });

        // WEBSOCKET:

        BridgeOptions opts = new BridgeOptions()
            .addInboundPermitted(new PermittedOptions().setAddressRegex("*"))
            .addOutboundPermitted(new PermittedOptions().setAddressRegex("*"));

        // Create the event bus bridge and add it to the router.
        SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts, event -> {
            if (event.type() == BridgeEventType.SOCKET_CREATED) {
                System.out.println("A socket was created");
            } else {
                System.out.println(event.type());
            }

            event.complete(true);
        });

        router.route("/eventbus/*").handler(ebHandler);

        // Create the HTTP server and pass the "accept" method to the request handler.
        vertx
            .createHttpServer()
            .requestHandler(router::accept)
            .listen(
                    // Retrieve the port from the configuration,
                    // default to 8080.
                    config().getInteger("http.port", 8080),
                    result -> {
                        if (result.succeeded()) {
                            fut.complete();
                        } else {
                            fut.fail(result.cause());
                        }
                    }
            );
    }
}

Instead of adding a SockJSHanlder , I have tried to use websocketHandler on the HttpServer , and that's working fine, but I would like to do it the other way around.

My test code:

HttpClient httpClient = client.websocket(PORT, "localhost", "/eventbus", headers, ws -> {
    ws.handler(buffer -> {
        JsonObject message = new JsonObject(buffer.toString());

        assertTrue(message.containsKey("type"));

        ws.close();

        async.complete();
    });

    ws.write(Buffer.buffer("{ \"type\": \"test\"}"));
});

Answer 1

You should move the handler:

router.route("/eventbus/*").handler(ebHandler);

Higher in your list. The issue is that you have global handlers that will be executed first and will not allow this handler to process the protocol upgrade to sockjs. These handlers are:

router.route().handler(CookieHandler.create());
router.route().handler(BodyHandler.create());
router.route().handler(SessionHandler....);
router.route().handler(ctx -> {
  ctx.fail(404);
});

Since router.route() will be called for any path they will interfere with your protocol upgrade. If you move the sockjs handler before those it should be executed first and your code should work.