See this tutorial of creating a Java websocket server and a Java websocket client.

package configurator;

import jakarta.websocket.HandshakeResponse;
import jakarta.websocket.server.HandshakeRequest;
import jakarta.websocket.server.ServerEndpointConfig;

public class MyServerConfigurator extends ServerEndpointConfig.Configurator {

    @Override
    public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {

        if (request.getHeaders().containsKey("Authorization")) {
            config.getUserProperties().put("Authorization", request.getHeaders().get("Authorization").get(0));
        }
        if (request.getHeaders().containsKey("CustomerName")) {
            config.getUserProperties().put("CustomerName", request.getHeaders().get("CustomerName").get(0));
        }
    }
}
        

package websocket;

import configurator.MyServerConfigurator;
import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;
import java.io.IOException;

@ServerEndpoint(value = "/mywebsocket", configurator = MyServerConfigurator.class)
public class MyWebsocketServer {

    private String customerName = null;

    @OnOpen
    public void onOpen(Session session, EndpointConfig endpointConfig) {

        String authorization = (String)endpointConfig.getUserProperties().get("Authorization");
        if (!"my_code".equals(authorization)) {
            try {
                CloseReason closeReason = new CloseReason(CloseReason.CloseCodes.NORMAL_CLOSURE, "Not Authorized");
                session.close(closeReason);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
        customerName = (String)endpointConfig.getUserProperties().get("CustomerName");
        System.out.println("Session " + session.getId() + " opened for " + customerName);
    }

    @OnMessage(maxMessageSize = 1048576)
    public void onMessage(String message, Session session) {

        String reply = "Hi " + customerName + ", thanks for your message - " + message;
        try {
            session.getBasicRemote().sendText(reply);
        }
        catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

    @OnClose
    public void onClose(Session session) {

        System.out.println("Session " + session.getId() + " closed");
    }

    @OnError
    public void onError(Throwable exception, Session session) {

        System.out.println("Session " + session.getId() + " had error:");
        exception.printStackTrace();
    }
}
        

package configurator;

import jakarta.websocket.ClientEndpointConfig;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyClientConfigurator extends ClientEndpointConfig.Configurator {

    private Map<String, List<String>> headers = new HashMap<>();

    public void setHeaders(Map<String, List<String>> headers) {
        this.headers = headers;
    }

    @Override
    public void beforeRequest(Map<String, List<String>> headers){

        for (String key : this.headers.keySet()) {

            headers.put(key, this.headers.get(key));
        }
    }
}
        

package websocket;

import configurator.MyClientConfigurator;

import jakarta.websocket.*;
import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyWebSocketClient extends Endpoint {

    private final String SERVER_URL = "ws://localhost:8080/WebSocketServer-1.0/mywebsocket";
    private Session session = null;

    public void connect(String authorization, String customerName) {

        Map<String, List<String>> headers = new HashMap<>();
        headers.put("Authorization", List.of(authorization));
        headers.put("CustomerName", List.of(customerName));

        MyClientConfigurator myClientConfigurator = new MyClientConfigurator();
        myClientConfigurator.setHeaders(headers);

        ClientEndpointConfig clientEndpointConfig = ClientEndpointConfig.Builder.create().configurator(myClientConfigurator).build();
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();

        try {
            container.connectToServer(this, clientEndpointConfig, new URI(SERVER_URL));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void disconnect() {
        try {
            this.session.close();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void sendText(String text) {

        try {
            this.session.getBasicRemote().sendText(text);
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onOpen(final Session session, EndpointConfig endpointConfig) {

        this.session = session;

        session.addMessageHandler(new MessageHandler.Whole<String>() {

            @Override
            public void onMessage(String text) {
                System.out.println("!!" + text + "!!");
            }
        });
    }

    @Override
    public void onClose(Session userSession, CloseReason reason) {

        System.out.println("Connection closed with reason: " + reason.getReasonPhrase());
    }

    @Override
    public void onError(Session session, Throwable t) {

        System.out.println("Had error:");
        t.printStackTrace();
    }
}
        

import websocket.MyWebSocketClient;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class MainClass {

    public static void main(String[] args) {

        MyWebSocketClient myWebSocketClient = new MyWebSocketClient();
        myWebSocketClient.connect("my_code","Sam");

        BufferedReader br = new BufferedReader((new InputStreamReader(System.in)));

        try {
            while (true) {
                System.out.println("Please enter command ('Send' or 'End')");

                String command = br.readLine();

                if (command.startsWith("Send")) {
                    System.out.println("What to send?");
                    command = br.readLine();
                    myWebSocketClient.sendText(command);

                    // A little sleep to make sure the ack message from the server will be received and printed out before going for next loop.
                    // Synchronization code like wait() and notify() could be used to precisely control the event flow if needed.
                    Thread.sleep(2000);
                }
                else if (command.startsWith("End")) {
                    myWebSocketClient.disconnect();
                    break;
                }
                else {
                    System.out.println("Please enter 'Send' or 'End' only");
                }
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}
        

Please enter command ('Send' or 'End')
Send
What to send?
Good to see you
!!Hi Sam, thanks for your message - Good to see you!!
Please enter command ('Send' or 'End')
End
Connection closed with reason: