Human-readable method names for web socket API (Java)

Describe the feature

What about renaming the method names handle() in the websocket handler endpoints CloseHandler, MessageHandkler, ConnectHandler, and so on?

The target is to make Java class-based implementations more readable instead of having multiple handle() methods on the same class.

Additional context

Current

  private static class FooWebsocket implements CloseHandler, MessageHandler, ConnectHandler, ErrorHandler, BinaryMessageHandler {

    @Override
    public void handle(WsSession session) throws Exception {}

    @Override
    public void handle(WsSession session, String msg) throws Exception {}

    @Override
    public void handle(WsSession session, int statusCode, String reason) throws Exception {}

    @Override
    public void handle(WsSession session, Byte[] msg, int offset, int length) throws Exception {}

    @Override
    public void handle(WsSession session, Throwable throwable) throws Exception {}
  }

Idea 1

  private static class FooWebsocket implements CloseHandler, MessageHandler, ConnectHandler, ErrorHandler, BinaryMessageHandler {

    @Override
    public void onConnect(WsSession session) throws Exception {}

    @Override
    public void onMessage(WsSession session, String msg) throws Exception {}

    @Override
    public void onClose(WsSession session, int statusCode, String reason) throws Exception {}

    @Override
    public void onBinaryMessage(WsSession session, Byte[] msg, int offset, int length) throws Exception {}

    @Override
    public void onError(WsSession session, Throwable throwable) throws Exception {}
  }

Idea 2

  /**
   * Usage: `app.ws("/my/websocket", Websocket.of(new MyWobsocketHandlers()))`
   *
   * `class MyWebsicketHandlers implements WsHandlers { ... }`
   */
  private static final class Websocket implements Consumer<WsHandler> {

    private final WsHandlers delegate;

    private Websocket(WsHandlers delegate) {
      this.delegate = delegate;
    }

    @Override
    public void accept(WsHandler t) {
      t.onConnect(delegate::onConnect);
      t.onMessage(delegate::onMessage);
      /* .. */
    }

    public static interface WsHandlers {
      public abstract void onConnect(WsSession session) throws Exception;
      public abstract void onMessage(WsSession session, String msg);
      /* .. */  
    }

    public static Websocket of(WsHandlers handlers) {
      return new BaseWsHandler(handlers);
    }

  }

#514

[ernestas2k]

@dherges Actually I like your as well as @tipsy approaches. If you still wish to have class that overrides methods it needs, you could quickly create helper class in your project:

// copy paste this class into your project
class WsHandlerBase {

    //@formatter:off
    protected void onConnect(WsConnectContext ctx) {}
    protected void onMessage(WsMessageContext ctx) {}
    protected void onBinaryMessage(WsBinaryMessageContext ctx) {}
    protected void onClose(WsCloseContext ctx) {}
    protected void onError(WsErrorContext ctx) {}
    //@formatter:on

    public final Consumer<WsHandler> build() {
        return ws -> {
            ws.onConnect(this::onConnect);
            ws.onMessage(this::onMessage);
            ws.onBinaryMessage(this::onBinaryMessage);
            ws.onClose(this::onClose);
            ws.onError(this::onError);
        };
    }
}

// your implementation the way you wanted
class MyWsHandler extends WsHandlerBase {

    @Override
    public void onConnect(WsConnectContext ctx) {
        System.out.println("connected");
    }

    @Override
    public void onMessage(WsMessageContext ctx) {
        ctx.send("echo:" + ctx.message());
    }

}
// usage
public class WebSocketsTest {
    public static void main(String[] args) {
        Javalin app = Javalin.create().enableDebugLogging().port(7070);
        app.ws("/test", new MyWsHandler().build());
        app.start();
    }
}

[tipsy]

I see! You could also do:

app.ws("/websocket", new WsClass()::handle);

...

class WsClass {

    public void handle(WsHandler ws) {
        ws.onConnect(ctx -> {
            System.out.println("Connected");
            ctx.send("[MESSAGE FROM SERVER] Connection established");
        });
        ws.onMessage(ctx -> {
            System.out.println("Received: " + ctx.message());
            ctx.send("[MESSAGE FROM SERVER] Echo: " + ctx.message());
        });
        ws.onClose(ctx -> {
            System.out.println("Closed");
        });
        ws.onError(ctx -> {
            System.out.println("Errored");
        });
    }

}

Is a new class really necessary? 🤔