Java中如何将WebSocket客户端数据传递至ClientManager

下面是几种低性能损耗的实现方案，直接解决数据传递和共享问题：

方案1：构造注入ClientManager引用（最优低损耗） #

直接在AuthClient初始化时注入ClientManager实例，回调中直接调用其方法，无额外中间层开销。

// AuthClient类
public class AuthClient extends WebSocketClient {
    private final ClientManager clientManager;

    // 构造时传入ClientManager实例
    public AuthClient(URI serverUri, ClientManager clientManager) {
        super(serverUri);
        this.clientManager = clientManager;
    }

    @Override
    public void onMessage(String message) {
        // 解析消息状态（hello/pending_finish/finish）
        String status = extractStatusFromMessage(message);
        // 直接传递数据到ClientManager
        clientManager.processClientMessage(this, status, message);
    }

    // 状态解析逻辑示例
    private String extractStatusFromMessage(String message) {
        // 实现你的状态解析逻辑，比如JSON解析取对应字段
        return "";
    }
}

// ClientManager类
public class ClientManager {
    private final Map<String, AuthClient> clientMap = new ConcurrentHashMap<>();

    public void registerClient(AuthClient client) {
        clientMap.put(getClientId(client), client);
    }

    public void processClientMessage(AuthClient client, String status, String rawMessage) {
        // 根据状态处理业务逻辑
        switch (status) {
            case "hello":
                handleClientHello(client);
                break;
            case "pending_finish":
                handleClientPendingFinish(client);
                break;
            case "finish":
                handleClientFinish(client);
                break;
        }
    }

    // 各状态处理方法
    private void handleClientHello(AuthClient client) { /* ... */ }
    private void handleClientPendingFinish(AuthClient client) { /* ... */ }
    private void handleClientFinish(AuthClient client) { /* ... */ }

    private String getClientId(AuthClient client) {
        // 返回客户端唯一标识，比如WebSocket session ID
        return client.getSessionId();
    }
}

方案2：全局单例ClientManager（适合单实例场景） #

如果ClientManager是全局唯一的，直接通过单例引用传递数据，省去注入步骤，性能损耗同样极低。

// ClientManager单例实现
public class ClientManager {
    private static final ClientManager INSTANCE = new ClientManager();
    private final Map<String, AuthClient> clientMap = new ConcurrentHashMap<>();

    private ClientManager() {}

    public static ClientManager getInstance() {
        return INSTANCE;
    }

    // 其余方法同方案1...
}

// AuthClient类调整
public class AuthClient extends WebSocketClient {
    @Override
    public void onMessage(String message) {
        String status = extractStatusFromMessage(message);
        // 直接调用单例方法传递数据
        ClientManager.getInstance().processClientMessage(this, status, message);
    }
}

方案3：轻量级事件委托（低耦合+低损耗） #

如果不想AuthClient直接依赖ClientManager，用极简函数式接口做委托，JVM会内联优化接口调用，几乎无性能损耗。

// 定义轻量级消息回调接口
@FunctionalInterface
public interface ClientMessageHandler {
    void handleMessage(AuthClient client, String status, String rawMessage);
}

// AuthClient类
public class AuthClient extends WebSocketClient {
    private ClientMessageHandler messageHandler;

    public void setMessageHandler(ClientMessageHandler handler) {
        this.messageHandler = handler;
    }

    @Override
    public void onMessage(String message) {
        String status = extractStatusFromMessage(message);
        if (messageHandler != null) {
            messageHandler.handleMessage(this, status, message);
        }
    }
}

// ClientManager实现接口
public class ClientManager implements ClientMessageHandler {
    private final Map<String, AuthClient> clientMap = new ConcurrentHashMap<>();

    public void registerClient(AuthClient client) {
        clientMap.put(getClientId(client), client);
        client.setMessageHandler(this); // 绑定回调
    }

    @Override
    public void handleMessage(AuthClient client, String status, String rawMessage) {
        // 状态处理逻辑同方案1...
    }
}

方案选择建议 #

• 优先选构造注入，性能最优且耦合合理，适合大多数场景。
• 全局单例适合系统只有一个ClientManager的场景，代码更简洁。
• 轻量级委托适合需要解耦的场景，避免硬依赖，同时保持低损耗。
• 避免使用重量级事件总线（如带反射、队列的框架），会引入不必要的性能开销。

内容的提问来源于stack exchange，提问作者user16976770