How to manage connected users over websocket using Vert.x 3?

Question

To convince some people to switch from old school tech, I need to build a chat demo application that manages more than 10K concurrent connections using Java (like Node.Js stuff).

I have tested Netty 5.0 which is awesome but requires lot of work to be done; on the other hand Jetty 9.3 is great but is slow compared to other competitors.

After some search I found the Vert.x 3 toolkit which is based on Netty with a plethora of great tools (no need to reinvent the wheel), I have seen the examples in git and I was able to build a websocket server, etc.

public void start() throws Exception {
    vertx.createHttpServer().websocketHandler(new Handler<ServerWebSocket>() {
        @Override
        public void handle(ServerWebSocket e) {
           // business stuff in the old style not yet lambda 
        }
    }).listen(port);
}

Being new to the Vert.x world, I could not figure out how to manage connected users using it, normally the old fashion way is to use something like:

HashMap<UUID,ServerWebSocket> connectedUsers;

When a connection is established I check if it exists; if not I add it as a new entry and do some functions to send, broadcast, retrieve through the collection and so on.

My question is does Vert.x 3 have something to deal with connections to track them and remove those who left (ping pong), broadcast, etc. or should I implement them from scratch using cookies, session, ....)

I could not find any real example using Vert.x 3.

Answer 1

Basically, the scope of the websocketHandler represents a connection. In your example this is your anonymous class. I created a little websocket chat example where I use the Vert.x event bus to distribute the messages to all the clients.

In the start method of the server we handle the websocket connections. You can implement the closeHandler to monitor client disconnection. There are also handlers for exceptions, ping-pong, etc. You can identify a specific connection by using the textHandlerID, but you have also access to the remote address.

 public void start() throws Exception {
        vertx.createHttpServer().websocketHandler(handler -> {
            System.out.println("client connected: "+handler.textHandlerID());

            vertx.eventBus().consumer(CHAT_CHANNEL, message -> {
                handler.writeTextMessage((String)message.body());
            });

            handler.textMessageHandler(message -> {
               vertx.eventBus().publish(CHAT_CHANNEL,message);
            });

            handler.closeHandler(message ->{
                System.out.println("client disconnected "+handler.textHandlerID());
            });

        }).listen(8080);
    }

The client example is also written in Java. It just prints all the received messages on the websocket connection to the console. After connection it sends a message.

public void start() throws Exception {
        HttpClient client = vertx.createHttpClient();

        client.websocket(8080, "localhost", "", websocket -> {
            websocket.handler(data -> System.out.println(data.toString("ISO-8859-1")));
            websocket.writeTextMessage(NAME+ ":hello from client");
        });

    }