前端传的请求头header怎么获取

[pu-wenjing]

前端传的请求header怎么获取到，或者说在SocketRequest中加一个叫private Map<String, Object> header的属性？我在使用过程中发现前端使用单例模式发起请求，并封装了了工具，但是会出现响应值交叉？是否有好的解决方案？以下是我的代码

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import axtk.face.clockin.constant.CommonConstant;

public class WebSocketClientServer {

    private WebSocketClient client = null;
    private static WebSocketClientServer instance;
    private WebSocketMessageListener messageListener;

    /**存储监听，方便分发消息*/
    private Map<String, WebSocketMessageListener> requestListeners = new HashMap<>();

    /**用于存储发送消息*/
    private String messageToSend;

    /**
     * 消息监听接口
     */
    public interface WebSocketMessageListener {
        void onMessageReceived(String message);
        void onErrorOccurred(Exception ex);
    }

    /**
     * 外部调用监听使用方法
     * @param listener
     */
    public void setMessageListener(WebSocketMessageListener listener) {
        messageListener = listener;
    }


    /**私有构造函数，避免外部类直接实例化*/
    private WebSocketClientServer() {
        connectWebSocket(); // 在构造函数中连接 WebSocket
    }

    /**
     * 获取实例
     * @return instance
     */
    public static synchronized WebSocketClientServer getInstance() {
        if (instance == null) {
            instance = new WebSocketClientServer();
        }
        return instance;
    }

    /**
     * 建立websocket连接
     */
    public void connectWebSocket() {
        try {
            client = new WebSocketClient(new URI(CommonConstant.WS_URL)) {
                @Override
                public void onOpen(ServerHandshake handshake) {
                    // WebSocket连接成功建立
                    System.out.println("WebSocket connection established.");
                    // 在连接成功后发送消息
                    if (messageToSend != null) {
                        sendMessage(messageToSend);
                        messageToSend = null; // 重置消息
                    }
                }

                @Override
                public void onMessage(String message) {
                    // 收到服务器返回的消息
                    System.out.println("Received message: " + message);
                    // 将消息传递给回调接口
                    if (messageListener != null) {
                        messageListener.onMessageReceived(message);
                    }
                }

                @Override
                public void onClose(int code, String reason, boolean remote) {
                    // WebSocket连接关闭
                    System.out.println("WebSocket connection closed.");
                    client = null;
                    // 重新连接
                    connectWebSocket();
                }

                @Override
                public void onError(Exception ex) {
                    // 发生错误
                    System.err.println("WebSocket error: " + ex.getMessage());
                    // 将错误传递给回调接口
                    if (messageListener != null) {
                        messageListener.onErrorOccurred(ex);
                    }
                }
            };
            // 设置 Header 属性
            client.addHeader("Authorization", "Bearer your_access_token");
            client.connect();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }


    // 生成唯一标识符的方法
    private String generateRequestId() {
        return UUID.randomUUID().toString();
    }

    /**
     * 接收到后端的响应时调用的方法
     * @param response 响应结果
     * @param requestId 请求唯一标识
     */
    public void handleResponse(String response, String requestId) {
        // 根据 requestId 找到对应的请求监听器
        WebSocketMessageListener listener = requestListeners.get(requestId);
        if (listener != null) {
            // 调用监听器的方法，将响应传递给前端
            listener.onMessageReceived(response);
            // 处理完响应后，移除该请求对应的监听器
            requestListeners.remove(requestId);
        } else {
            // 如果找不到对应的请求监听器，可能是请求超时或出现了其他异常，可以进行相应的处理
            System.err.println("Received response with unknown requestId: " + requestId);
        }
    }

    /**
     * 是否建立连接
     *
     * @return
     */
    private boolean isConnected() {
        return client != null && client.isOpen();
    }

    /**
     * 建立连接后发起请求
     *
     * @param message 发送的消息
     */
    public void sendMessage(String message) {
        if (isConnected()) {
            // 将请求监听器与标识符绑定
            String requestId = generateRequestId();
            requestListeners.put(requestId, messageListener);
            
            client.send(message);
        } else {
            // 如果没有连接建立，则保存消息，等待连接建立后发送
            messageToSend = message;
        }
    }



}

请求代码：

              WebSocketClientServer clientServer = WebSocketClientServer.getInstance();
                clientServer.setMessageListener(new WebSocketClientServer.WebSocketMessageListener() {
                    @Override
                    public void onMessageReceived(String message) {
                        System.out.println("TAG-initFaceSignList: " + message);
                    }
                    @Override
                    public void onErrorOccurred(Exception ex) {

                    }
                });

                Map<String, Object> messageData = new HashMap<>();
                messageData.put("url", CommonConstant.FACE_SIGN_LIST_URL);
                Map<String, String> params = new HashMap<>();
                params.put("meetingId", currentId);
                messageData.put("params", params);
                String jsonMessage = gson.toJson(messageData);
                clientServer.sendMessage(jsonMessage);