WebSockets & Real-Time Systems with Spring · 课时

使用 STOMP 实现私信

学习如何使用 STOMP 的用户目标地址，实现用户之间一对一的私密消息传递。

第 3 / 4 课11 个步骤

使用 STOMP 实现私信 是 CoddyKit 上的免费 WebSockets & Real-Time Systems with Spring 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 WebSockets & Real-Time Systems with Spring 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 WebSockets & Real-Time Systems with Spring 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Private Chat Essentials

Welcome! In this lesson, we'll learn how to build private messaging functionality into our chat application using WebSockets and STOMP.

Unlike public chat rooms where everyone receives messages, private messages (like direct messages or DMs) are sent specifically from one user to another. This requires a way to route messages directly to an individual's unique session.

STOMP User Destinations

STOMP provides a special destination prefix: /user. When a client subscribes to a destination like /user/queue/private-messages, the STOMP broker (and Spring) automatically translate this into a unique, session-specific queue for that particular authenticated user.

/user prefix: Indicates a user-specific destination.
Unique per user: Each user gets their own 'inbox' for private messages.
Abstracted routing: You don't need to know the actual session ID.

Spring & User Routes

Spring's WebSocket and STOMP integration works hand-in-hand with the /user prefix. When you configure your message broker, you tell Spring to enable user destinations:

config.setUserDestinationPrefix("/user");

This setting ensures that messages addressed to /user/{username}/queue/{destination} are correctly routed by Spring to the WebSocket session(s) associated with {username}.

Server-Side: Sending Private Messages

On the server, Spring provides the SimpMessagingTemplate. This powerful tool allows you to send messages to various STOMP destinations, including user-specific ones.

The key method for private messaging is convertAndSendToUser(). It takes three main arguments:

username: The identifier of the recipient user.
destination: The specific queue within that user's private space (e.g., /queue/private-messages).
payload: The actual message content.

Server Private Send Demo

Try running this simplified Spring Boot application. It shows a controller method that sends a private message using SimpMessagingTemplate. Remember, in a real app, the recipient's username would come from the client's message payload or other context.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.stereotype.Controller;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import java.security.Principal;

@SpringBootApplication
@EnableWebSocketMessageBroker
public class PrivateChatApp {

    public static void main(String[] args) {
        SpringApplication.run(PrivateChatApp.class, args);
    }

    @Configuration
    static class WsConfig implements WebSocketMessageBrokerConfigurer {
        @Override
        public void configureMessageBroker(MessageBrokerRegistry cfg) {
            cfg.enableSimpleBroker("/topic", "/queue");
            cfg.setApplicationDestinationPrefixes("/app");
            cfg.setUserDestinationPrefix("/user"); // Crucial for private messages
        }
        @Override
        public void registerStompEndpoints(StompEndpointRegistry reg) {
            reg.addEndpoint("/ws").withSockJS();
        }
    }

    @Controller
    static class PrivateMsgController {
        private final SimpMessagingTemplate template;

        public PrivateMsgController(SimpMessagingTemplate t) {
            this.template = t;
        }

        @MessageMapping("/sendPrivate") // Client sends to /app/sendPrivate
        public void sendPrivateMsg(String msg, Principal p) {
            String sender = p != null ? p.getName() : "anon";
            String recipient = "targetUser"; // In real app, from msg payload

            // Send to a specific user's private queue
            template.convertAndSendToUser(
                recipient,
                "/queue/private-messages", // Client subscribes here
                "From " + sender + ": " + msg
            );
            System.out.println("Sent private msg to " + recipient + " from " + sender);
        }
    }
}

Client's Private Inbox

On the client side, a user needs to subscribe to their own private destination to receive messages. If a user's principal name is 'alice', they would subscribe to:

/user/queue/private-messages

Spring automatically maps this to /queue/private-messages-user{sessionId} internally, ensuring only 'alice' receives messages sent to her.

Client-Side Subscription

Using a STOMP client library (like Stomp.js), the subscription process is straightforward:

stompClient.subscribe('/user/queue/private-messages', function(message) {
    // Handle the private message
    console.log("Received private message: " + message.body);
});

This ensures that any message sent to the currently authenticated user's /queue/private-messages destination will be received by this client.

Private Message Model

For robust private chat, your message payload should contain structured data. A typical private message model might include:

senderId: The ID of the user who sent the message.
recipientId: The ID of the user intended to receive the message.
content: The actual text or data of the message.
timestamp: When the message was sent.

This allows clients to display messages correctly, identifying who sent what to whom.

User Identity & STOMP

How does Spring know which user is 'alice' for the /user destination? It relies on the Principal object, which is usually populated by Spring Security or another authentication mechanism.

When a WebSocket connection is established, Spring associates a Principal with that session. The convertAndSendToUser() method uses the getName() of this Principal to identify the target user.

Private Message Quiz

You've learned how Spring and STOMP handle private messages. Let's test your understanding of sending them.

在交互式课程中回答

Private Chat Summary

Great job! You've learned the fundamentals of implementing private messaging with STOMP and Spring.

The /user destination prefix routes messages to individual users.
Spring's SimpMessagingTemplate.convertAndSendToUser() sends messages to specific user destinations.
Clients subscribe to /user/queue/{your-private-destination} to receive their DMs.
User identity (Principal) is crucial for correct routing.

This knowledge allows you to build sophisticated, personalized real-time interactions in your applications!

免费开始

用 AI 导师学习 WebSockets & Real-Time Systems with Spring — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 48

免费开始学习查看完整课程

常见问题解答

「使用 STOMP 实现私信」课时是免费的吗？

是的 — 「使用 STOMP 实现私信」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 WebSockets & Real-Time Systems with Spring 课程的其余内容，请升级到 CoddyKit PRO。 WebSockets & Real-Time Systems with Spring 课程共包含 4 节课。

「使用 STOMP 实现私信」这节课中我会学到什么？

学习如何使用 STOMP 的用户目标地址，实现用户之间一对一的私密消息传递。你通过在浏览器中直接运行的动手代码来练习 WebSockets & Real-Time Systems with Spring，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 WebSockets & Real-Time Systems with Spring 需要有经验吗？

无需任何先前经验。CoddyKit 上的 WebSockets & Real-Time Systems with Spring 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「使用 STOMP 实现私信」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 WebSockets & Real-Time Systems with Spring 课中编写并运行代码吗？

能。每节 WebSockets & Real-Time Systems with Spring 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 WebSockets & Real-Time Systems with Spring