Spring Boot: WebSocket with STOMP?

Question

Accepted Answer

**STOMP over WebSocket** — a higher-level messaging protocol that works over WebSocket and supports **topics, queues, and subscriptions**.

**Simple analogy:** WebSocket is like a wire (low-level). STOMP is like a telephone protocol (subscriber → number → conversation). You subscribe to a "channel" and receive messages. Think of it as a walkie-talkie system: WebSocket is the physical radio, STOMP is the protocol that lets you say "I want to listen to Channel 5" (subscribe) and "I'm sending a message to Channel 3" (send). Without STOMP, you would have to build the routing and subscription logic yourself.

**Why it matters:** Raw WebSocket gives you a bidirectional pipe but no built-in concepts of topics, queues, or message routing. STOMP adds this layer, making it trivial to build chat rooms, live dashboards, collaborative editing, and real-time notifications without reinventing message routing.

**Configuration:**
```java
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

@Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic", "/queue");  // Message broker
        config.setApplicationDestinationPrefixes("/app");  // Application prefix
        config.setUserDestinationPrefix("/user");  // Per-user queue prefix
    }

@Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws")
            .setAllowedOrigins("*")
            .withSockJS();  // Fallback for older browsers
    }
}
```

**Controllers:**
```java
@Controller
public class ChatController {

// Client sends to /app/chat.send
    @MessageMapping("/chat.send")
    @SendTo("/topic/messages")  // Broadcasts to all subscribers
    public Message sendMessage(Message message) {
        return message;
    }

// Private messages (to single user)
    @MessageMapping("/chat.private")
    @SendToUser("/queue/messages")
    public Message sendPrivate(Message message, Principal principal) {
        message.setSender(principal.getName());
        return message;
    }
    
    // Sending to a specific user programmatically
    @MessageMapping("/chat.notification")
    public void sendNotification(@Payload NotificationEvent event,
            SimpMessageHeaderAccessor headerAccessor) {
        String userId = event.getTargetUserId();
        messagingTemplate.convertAndSendToUser(
            userId, "/queue/notifications", event
        );
    }
}
```

**Client (STOMP.js):**
```javascript
const stompClient = new StompJs.Client({
    brokerURL: "ws://localhost:8080/ws",
    onConnect: () => {
        stompClient.subscribe("/topic/messages", (message) => {
            console.log(JSON.parse(message.body));
        });
        
        stompClient.subscribe("/user/queue/messages", (message) => {
            console.log("Private:", JSON.parse(message.body));
        });
    },
    onDisconnect: () => console.log("Disconnected"),
    reconnectDelay: 5000
});
stompClient.activate();

// Sending
stompClient.publish({
    destination: "/app/chat.send",
    body: JSON.stringify({sender: "Alice", content: "Hello!"})
});
```

**Production considerations:**
- **Scaling across instances** — `SimpleBroker` is in-memory only. For multi-instance deployments, use RabbitMQ or external STOMP broker.
- **Authentication** — add `ChannelInterceptor` to validate STOMP headers before messages reach controllers.
- **Heartbeat** — configure `setHandshakeHandler()` to handle connection timeouts and clean up stale sessions.
- **Message size limits** — set `spring.websocket.max-text-message-size` and `max-binary-message-size` to prevent abuse.

Java: Spring Boot: WebSocket with STOMP?