WebSockets enable real-time, bidirectional communication in web applications, which is essential for features like live chat and notifications; unlike HTTP, they allow servers to push data instantly to clients. 1. Use Spring Boot with the spring-boot-starter-websocket dependency to simplify setup. 2. Configure WebSocket support via @EnableWebSocketMessageBroker, register STOMP endpoints (e.g., /ws), and enable a simple message broker for topics and queues. 3. Define a message model (e.g., Message class with sender and content). 4. Create a controller with @MessageMapping to handle incoming messages and @SendTo to broadcast responses. 5. On the client side, connect using SockJS and STOMP.js, subscribe to topics (e.g., /topic/public), and send messages to application endpoints (e.g., /app/chat.sendMessage). 6. For private messaging, use SimpMessagingTemplate to send messages to user-specific destinations (e.g., /user/queue/messages). 7. Secure endpoints with Spring Security by requiring authentication for WebSocket access. 8. Scale effectively by replacing the in-memory broker with Redis or RabbitMQ, minimizing session storage, and considering Spring WebFlux for reactive, high-concurrency support. With proper configuration and tools, Java and WebSockets provide a robust, production-ready solution for real-time communication.

Real-time communication is a must-have in modern web applications — from live chat and stock tickers to collaborative tools and live notifications. Java, being a robust and widely adopted backend language, pairs well with WebSockets to deliver full-duplex, bidirectional communication between clients and servers. Here’s how you can build real-time applications using Java and WebSockets effectively.

What Are WebSockets and Why Use Them?

HTTP is request-response based — the client asks, the server replies. But for real-time features, you need the server to push data to the client instantly, without waiting for a request. That’s where WebSockets come in.

WebSockets establish a persistent, low-latency connection between client and server. Once connected, either side can send messages at any time. Compared to older techniques like polling or Server-Sent Events (SSE), WebSockets offer:

• Lower latency
• Reduced overhead
• True two-way communication

Java EE (now Jakarta EE) has built-in support for WebSockets via the JSR 356 API, and Spring Framework enhances this with even simpler abstractions.

Setting Up WebSockets in Java (Using Spring Boot)

Spring Boot simplifies WebSocket integration with auto-configuration and annotation-driven development. Here's a step-by-step setup:

1. Add Dependencies

In your pom.xml (for Maven):

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

2. Enable WebSocket Support

Create a configuration class:

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS(); // SockJS for fallback
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setApplicationDestinationPrefixes("/app");
        registry.enableSimpleBroker("/topic", "/queue"); // In-memory broker
    }
}

This config:

• Exposes a WebSocket endpoint at /ws
• Uses STOMP (Simple Text Oriented Messaging Protocol) over WebSockets
• Enables an in-memory message broker for broadcasting

3. Create a Message Model

public class Message {
    private String content;
    private String sender;
    // constructors, getters, setters
}

4. Handle Messages with a Controller

@Controller
public class WebSocketController {

    @MessageMapping("/chat.sendMessage")
    @SendTo("/topic/public")
    public Message sendMessage(@Payload Message message) {
        return message;
    }
}

When a client sends a message to /app/chat.sendMessage, Spring routes it here and broadcasts the response to all subscribers of /topic/public.

Client-Side: Connecting with JavaScript

On the frontend, use the SockJS and STOMP.js libraries for easy integration:

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/@stomp/stompjs@6.1.0/bundles/stomp.umd.min.js"></script>

<script>
  const socket = new SockJS('/ws');
  const stompClient = Stomp.over(socket);

  stompClient.connect({}, function(frame) {
    console.log('Connected: '   frame);

    stompClient.subscribe('/topic/public', function(messageOutput) {
      const message = JSON.parse(messageOutput.body);
      console.log('Received:', message);
    });
  });

  // Send a message
  function sendMsg() {
    stompClient.send("/app/chat.sendMessage", {}, JSON.stringify({
      'sender': 'Alice',
      'content': 'Hello!'
    }));
  }
</script>

Now, every time sendMsg() is called, the server receives it and rebroadcasts it to all connected clients.

Advanced: User-Specific Messaging and Security

For private messaging or notifications, use user destinations:

@MessageMapping("/private.message")
public void sendPrivate(@Payload Message message, SimpMessagingTemplate messagingTemplate) {
    messagingTemplate.convertAndSendToUser(
        message.getRecipient(), "/queue/messages", message
    );
}

This sends a message directly to a specific user (e.g., /user/alice/queue/messages), ideal for notifications or DMs.

Also, secure your WebSocket endpoints using Spring Security:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
        .antMatchers("/ws/**").authenticated();
}

And ensure user authentication is passed during the WebSocket handshake.

Performance and Scalability Tips

While WebSockets are efficient, scaling them requires care:

• Use a message broker like RabbitMQ or Redis for clustering (replace simple broker in production)
• Avoid storing large session data in memory
• Implement heartbeats and connection timeouts
• Consider using Reactive WebSocket support in Spring WebFlux for high concurrency

Building real-time apps with Java and WebSockets isn’t just feasible — it’s elegant and production-ready. With Spring Boot’s powerful abstractions, you can go from idea to live updates in minutes.

Basically, set up the endpoint, define your message flow, and let STOMP and Spring handle the heavy lifting. It’s not magic — but it’s close.

The above is the detailed content of Building Real-Time Applications with Java and WebSockets. For more information, please follow other related articles on the PHP Chinese website!