End of Life for Twilio Programmable Video - Upgrade to VideoSDKLearn More

How to Implement Java WebSockets?

Learn how to implement Java WebSockets for real-time communication. This guide covers everything from setting up your environment and creating WebSocket servers

Introduction to Java WebSockets

WebSockets are a powerful technology that enables real-time, bidirectional communication between clients and servers over a single, long-lived connection. Unlike traditional HTTP, which follows a request-response pattern, WebSockets allow data to flow freely in both directions, making them ideal for applications that require instant updates, such as live chats, online gaming, and real-time notifications.
In this article, we will explore how to implement WebSockets in Java. By the end of this guide, you will have a comprehensive understanding of how to set up a WebSocket server and client, manage connections, handle messages, and ensure secure communication. Whether you are building a simple chat application or a complex real-time data streaming service, this guide will provide you with the tools and knowledge you need to get started with Java WebSockets.

Understanding WebSockets

WebSockets are a communication protocol that provides full-duplex communication channels over a single TCP connection. They enable real-time interaction between a client (such as a web browser) and a server, which is essential for applications requiring immediate data updates, like chat applications and live streaming. Unlike HTTP, which relies on a request-response model, WebSockets facilitate continuous, two-way communication.

Setting Up the Environment


Before diving into the implementation of WebSockets in Java, ensure you have the following tools and libraries installed:
  • Java Development Kit (JDK) 8 or higher
  • Maven or Gradle for dependency management
  • An Integrated Development Environment (IDE) like IntelliJ IDEA or Eclipse

Creating a New Project

Set Up a New Maven Project

  • Open your IDE and create a new Maven project.
  • Configure the pom.xml file to include dependencies for WebSocket support:


1     <dependency>
2         <groupId>javax.websocket</groupId>
3         <artifactId>javax.websocket-api</artifactId>
4         <version>1.1</version>
5     </dependency>
6     <dependency>
7         <groupId>org.glassfish.tyrus</groupId>
8         <artifactId>tyrus-standalone-client</artifactId>
9         <version>1.13</version>
10     </dependency>

Create Project Structure

  • Organize your project into packages (e.g., com.example.websocket).
  • Ensure a clean separation of concerns by having different packages for server and client implementations.

Implementing Java WebSocket Server

Start by creating a simple WebSocket server.

Define the WebSocket Endpoint

Create a new Java class, ChatServerEndpoint.java, and annotate it with @ServerEndpoint:


1     import javax.websocket.OnClose;
2     import javax.websocket.OnMessage;
3     import javax.websocket.OnOpen;
4     import javax.websocket.Session;
5     import javax.websocket.server.ServerEndpoint;
6     import java.io.IOException;
7     import java.util.Collections;
8     import java.util.HashSet;
9     import java.util.Set;
11     @ServerEndpoint("/chat")
12     public class ChatServerEndpoint {
13         private static Set<Session> clients = Collections.synchronizedSet(new HashSet<>());
15         @OnOpen
16         public void onOpen(Session session) {
17             clients.add(session);
18         }
20         @OnClose
21         public void onClose(Session session) {
22             clients.remove(session);
23         }
25         @OnMessage
26         public void onMessage(String message, Session session) throws IOException {
27             for (Session client : clients) {
28                 if (!client.equals(session)) {
29                     client.getBasicRemote().sendText(message);
30                 }
31             }
32         }
33     }


  • @ServerEndpoint("/chat"): Defines the WebSocket endpoint accessible at /chat.
  • onOpen(Session session): Adds new client sessions to the set of active clients.
  • onClose(Session session): Removes client sessions when they disconnect.
  • onMessage(String message, Session session): Broadcasts messages received from one client to all other connected clients.

Handling Client Connections

Lifecycle Events

WebSocket lifecycle events (onOpen, onClose, onMessage) manage client connections and messaging.

Session Management

Synchronized set ensures thread safety while managing client sessions.

Creating a Java WebSocket Client

Create a client that connects to the WebSocket server.

Define the WebSocket Client

Create a new Java class, ChatClient.java:


1     import javax.websocket.ClientEndpoint;
2     import javax.websocket.OnMessage;
3     import javax.websocket.Session;
4     import javax.websocket.ContainerProvider;
5     import javax.websocket.WebSocketContainer;
6     import java.net.URI;
8     @ClientEndpoint
9     public class ChatClient {
10         @OnMessage
11         public void onMessage(String message) {
12             System.out.println("Received: " + message);
13         }
15         public static void main(String[] args) throws Exception {
16             WebSocketContainer container = ContainerProvider.getWebSocketContainer();
17             String uri = "ws://localhost:8080/chat";
18             container.connectToServer(ChatClient.class, URI.create(uri));
19         }
20     }


  • @ClientEndpoint: Annotates the class as a WebSocket client endpoint.
  • onMessage(String message): Handles incoming messages from the server.
  • main(String[] args): Connects to the WebSocket server at ws://localhost:8080/chat.

Get Free 10,000 Minutes Every Months

No credit card required to start.

Advanced Features and Security

Enhance your WebSocket server with additional functionalities.

Broadcasting Messages

  • Modify onMessage to include broadcasting logic (already shown).

Session Management

  • Track user sessions for personalized messaging and handling.

Securing WebSocket Connections

Implement SSL/TLS

  • Configure your server to use HTTPS for secure communication.
  • Example with embedded Jetty server:


1     import org.eclipse.jetty.server.Server;
2     import org.eclipse.jetty.server.ServerConnector;
3     import org.eclipse.jetty.util.ssl.SslContextFactory;
4     import org.eclipse.jetty.websocket.server.WebSocketHandler;
5     import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
7     public class SecureChatServer {
8         public static void main(String[] args) throws Exception {
9             Server server = new Server();
10             ServerConnector connector = new ServerConnector(server);
12             // Set up SSL
13             SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
14             sslContextFactory.setKeyStorePath("keystore.jks");
15             sslContextFactory.setKeyStorePassword("password");
16             connector.addConnectionFactory(new SslConnectionFactory(sslContextFactory, "http/1.1"));
18             server.addConnector(connector);
19             server.setHandler(new WebSocketHandler() {
20                 @Override
21                 public void configure(WebSocketServletFactory factory) {
22                     factory.register(ChatServerEndpoint.class);
23                 }
24             });
26             server.start();
27             server.join();
28         }
29     }


  • Use SslContextFactory to configure SSL/TLS.
  • Ensure the keystore contains the necessary certificates.

Testing and Debugging


Use tools like Postman, browser developer tools, or custom scripts to test WebSocket connections.


Common issues include connection timeouts and message format errors. Use logs and debugging tools to identify and resolve issues.

Performance Optimization


  • Reduce latency by optimizing server response times.
  • Minimize the data sent over WebSocket connections.

Code Snippets

  • Implement techniques like message compression and efficient data structures to enhance performance.


In this article, we have explored the fundamental aspects of implementing WebSockets in Java. From setting up the environment to creating a WebSocket server and client, handling advanced features, ensuring security, and optimizing performance, this comprehensive guide provides you with the knowledge and tools needed to build robust real-time communication systems.
By following these steps, you can create applications that require immediate data updates, such as chat applications, live gaming, and real-time notifications. Start experimenting with WebSockets in your projects to unlock new possibilities in real-time web communication.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights