Java WebSocket - 1.0

package com.example;

import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;

@ServerEndpoint("/chat")
public class ChatServerEndpoint {

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("[SERVER] OPEN: " + session.getId());
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("[SERVER] RECV from " + session.getId() + ": " + message);
        try {
            // Echo the message back to the client
            session.getBasicRemote().sendText("echo: " + message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("[SERVER] CLOSE: " + session.getId() + " (" + reason + ")");
    }

    @OnError
    public void onError(Session session, Throwable t) {
        System.out.println("[SERVER] ERROR on " + session.getId());
        t.printStackTrace();
    }
}

</details>
<details><summary>ServerMain.java</summary>
``` java
package com.example;

import org.glassfish.tyrus.server.Server;

import java.util.Collections;

public class ServerMain {

    public static final String HOST = "localhost";
    public static final int    PORT = 8080;
    public static final String CONTEXT_PATH = "/app";   

    public static void main(String[] args) throws Exception {
        Server server = new Server(HOST, PORT, CONTEXT_PATH,
                Collections.emptyMap(),
                ChatServerEndpoint.class);

        try {
            server.start();
            System.out.println("[SERVER] Started at ws://" + HOST + ":" + PORT
                    + CONTEXT_PATH + "/chat");
            System.out.println("[SERVER] Press ENTER to stop...");
            System.in.read();   
        } finally {
            server.stop();
            System.out.println("[SERVER] Stopped.");
        }
    }
}

package com.example;

import org.eclipse.jetty.websocket.api.Callback;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketOpen;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;

@WebSocket  // autoDemand = true by default
public class ChatServerEndpoint {

    @OnWebSocketOpen
    public void onOpen(Session session) {
        System.out.println("[SERVER] OPEN: " + session.getRemoteSocketAddress());
    }

    @OnWebSocketMessage
    public void onMessage(Session session, String message) {
        System.out.println("[SERVER] RECV: " + message);
        // Echo it back. The async send takes a Callback (use NOOP to ignore completion).
        session.sendText("echo: " + message, Callback.NOOP);
    }

    @OnWebSocketClose
    public void onClose(int statusCode, String reason) {
        System.out.println("[SERVER] CLOSE: " + statusCode + " " + reason);
    }

    @OnWebSocketError
    public void onError(Throwable cause) {
        cause.printStackTrace();
    }
}

package com.example;

import java.net.URI;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.client.WebSocketClient;

public class JettyWsClient {

    public static void main(String[] args) throws Exception {
        WebSocketClient client = new WebSocketClient();
        Object endpoint = new JettyWsClientEndpoint();
        URI serverUri = URI.create("ws://localhost:8080/chat");

        try {
            client.start();
            System.out.println("[CLIENT] connecting to " + serverUri);

            CompletableFuture<Session> sessionPromise = client.connect(endpoint, serverUri);
            sessionPromise.get(5, TimeUnit.SECONDS);

            endpoint.awaitClose(5);
        } finally {
            client.stop();
        }
        System.out.println("[CLIENT] done.");
    }
}

package com.example;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import org.eclipse.jetty.websocket.api.Callback;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.StatusCode;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketOpen;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;

@WebSocket
public class JettyWsClientEndpoint {

    private final CountDownLatch closeLatch = new CountDownLatch(1);

    @OnWebSocketOpen
    public void onOpen(Session session) {
        System.out.println("[CLIENT] connected");
        session.sendText("hello server", Callback.NOOP);   // � outgoing message
    }

    @OnWebSocketMessage
    public void onMessage(Session session, String message) {
        System.out.println("[CLIENT] received: " + message);
        session.close(StatusCode.NORMAL, "done", Callback.NOOP);
    }

    @OnWebSocketClose
    public void onClose(int statusCode, String reason) {
        System.out.println("[CLIENT] closed: " + statusCode + " " + reason);
        closeLatch.countDown();
    }

    @OnWebSocketError
    public void onError(Throwable cause) {
        cause.printStackTrace();
    }

    public boolean awaitClose(int seconds) throws InterruptedException {
        return closeLatch.await(seconds, TimeUnit.SECONDS);
    }
}

package com.example;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.websocket.server.WebSocketUpgradeHandler;

public class ServerMain {

    public static void main(String[] args) throws Exception {
        
        Server server = new Server(8080);

        WebSocketUpgradeHandler wsHandler = WebSocketUpgradeHandler.from(server);
        server.setHandler(wsHandler);

        wsHandler.getServerWebSocketContainer()
                 .addMapping("/chat",
                         (upgradeRequest, upgradeResponse, callback) -> new ChatServerEndpoint());

        server.start();
        System.out.println("[SERVER] Started at ws://localhost:8080/chat");
        server.join();   
    }
}

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;

import java.net.URI;

public class NettyWsClient {

    private final URI serverUri;

    public NettyWsClient(URI serverUri) {
        this.serverUri = serverUri;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker(
                    serverUri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders());

            NettyWsClientHandler handler = new NettyWsClientHandler(handshaker);

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                     .channel(NioSocketChannel.class)
                     .handler(new NettyWsClientInitializer(handler));

            Channel channel = bootstrap.connect(serverUri.getHost(), serverUri.getPort()).sync().channel();
            handler.handshakeFuture().sync();

            channel.writeAndFlush(new TextWebSocketFrame("Hello from config-builder client"));

            Thread.sleep(1000);
            channel.close().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        URI uri = URI.create("ws://localhost:8080/ws/chat");
        new NettyWsClient(uri).start();
    }
}

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolConfig;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;

public class NettyWsServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) {
        WebSocketServerProtocolConfig config = WebSocketServerProtocolConfig.newBuilder()
                .websocketPath("/ws/chat")
                .checkStartsWith(true)
                .build();

        ch.pipeline()
          .addLast(new HttpServerCodec())
          .addLast(new HttpObjectAggregator(65536))
          .addLast(new WebSocketServerProtocolHandler(config))
          .addLast(new NettyWsFrameHandler());
    }
}