实时通信系统设计：如何避免服务器存储客户端URL并建立高效连接

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // 启用简单的内存消息代理，将消息从服务器路由到客户端
        // 客户端订阅 /topic/* 和 /user/*
        config.enableSimpleBroker("/topic", "/user");
        // 配置应用程序的目的地前缀，客户端发送消息到 /app/*
        config.setApplicationDestinationPrefixes("/app");
        // 配置用户目的地前缀，用于一对一消息
        config.setUserDestinationPrefix("/user");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 注册一个STOMP端点，客户端将使用它连接到WebSocket服务器
        // withSockJS() 提供回退选项，以便在WebSocket不可用时使用SockJS
        registry.addEndpoint("/ws").withSockJS();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Controller;

import java.security.Principal;

@Controller
public class ChatController {

    @Autowired
    private SimpMessagingTemplate messagingTemplate;

    /**
     * 处理广播消息：客户端发送消息到 /app/chat.sendMessage
     * 服务器将消息广播到 /topic/public
     */
    @MessageMapping("/chat.sendMessage")
    @SendTo("/topic/public")
    public ChatMessage sendMessage(@Payload ChatMessage chatMessage, Principal principal) {
        // 在这里可以添加业务逻辑，例如保存消息到数据库
        System.out.println("Received broadcast message from " + principal.getName() + ": " + chatMessage.getContent());
        return chatMessage;
    }

    /**
     * 处理用户加入聊天室：客户端发送消息到 /app/chat.addUser
     * 服务器将用户加入通知广播到 /topic/public
     */
    @MessageMapping("/chat.addUser")
    @SendTo("/topic/public")
    public ChatMessage addUser(@Payload ChatMessage chatMessage, SimpMessageHeaderAccessor headerAccessor, Principal principal) {
        // 将用户信息添加到WebSocket会话属性中（可选）
        headerAccessor.getSessionAttributes().put("username", chatMessage.getSender());
        System.out.println(chatMessage.getSender() + " joined the chat.");
        return chatMessage;
    }

    /**
     * 处理私聊消息：客户端发送消息到 /app/chat.privateMessage
     * 服务器将消息发送给指定用户
     */
    @MessageMapping("/chat.privateMessage")
    public void sendPrivateMessage(@Payload ChatMessage chatMessage, Principal principal) {
        // principal.getName() 获取当前发送者的用户名
        String sender = principal.getName();
        String recipient = chatMessage.getRecipient(); // 假设消息体中包含接收者信息
        String content = chatMessage.getContent();

        System.out.println("Received private message from " + sender + " to " + recipient + ": " + content);

        // 使用 messagingTemplate 向特定用户发送消息
        // /user/{recipient}/queue/private 约定用于私聊消息
        messagingTemplate.convertAndSendToUser(recipient, "/queue/private", chatMessage);
    }
}

// 消息实体类
public class ChatMessage {
    private MessageType type;
    private String content;
    private String sender;
    private String recipient; // for private messages

    // Getters and Setters
    public MessageType getType() { return type; }
    public void setType(MessageType type) { this.type = type; }
    public String getContent() { return content; }
    public void setContent(String content) { this.content = content; }
    public String getSender() { return sender; }
    public void setSender(String sender) { this.sender = sender; }
    public String getRecipient() { return recipient; }
    public void setRecipient(String recipient) { this.recipient = recipient; }
}

public enum MessageType {
    CHAT, JOIN, LEAVE
}

var stompClient = null;

function connect() {
    var socket = new SockJS('/ws'); // 连接到 /ws 端点
    stompClient = Stomp.over(socket);
    stompClient.connect({}, onConnected, onError);
}

function onConnected() {
    // 订阅公共聊天主题
    stompClient.subscribe('/topic/public', onMessageReceived);
    // 订阅私聊队列 (用户需要认证才能接收私聊)
    // 假设用户名为 'currentUser'
    stompClient.subscribe('/user/queue/private', onPrivateMessageReceived);

    // 发送用户加入消息
    stompClient.send("/app/chat.addUser",
        {},
        JSON.stringify({sender: 'currentUser', type: 'JOIN'})
    );
}

function onError(error) {
    console.log('Could not connect to WebSocket server. Please refresh this page to try again!', error);
}

function sendPublicMessage() {
    var chatMessage = {
        sender: 'currentUser',
        content: 'Hello Everyone!',
        type: 'CHAT'
    };
    stompClient.send("/app/chat.sendMessage", {}, JSON.stringify(chatMessage));
}

function sendPrivateMessage(recipient, messageContent) {
    var chatMessage = {
        sender: 'currentUser',
        recipient: recipient,
        content: messageContent,
        type: 'CHAT'
    };
    stompClient.send("/app/chat.privateMessage", {}, JSON.stringify(chatMessage));
}

function onMessageReceived(payload) {
    var message = JSON.parse(payload.body);
    console.log('Received public message:', message);
    // 更新UI显示消息
}

function onPrivateMessageReceived(payload) {
    var message = JSON.parse(payload.body);
    console.log('Received private message:', message);
    // 更新UI显示私聊消息
}

// 示例用法
connect();
// setTimeout(sendPublicMessage, 2000);
// setTimeout(() => sendPrivateMessage('anotherUser', 'Hi there!'), 5000);