Java Websocket Development Guide: How to implement real-time communication between client and server, specific code examples are required

With the continuous development of Web applications, real-time communication has become an essential part of the project. In the traditional HTTP protocol, the client sends a request to the server, and the data can only be obtained after receiving the response. This causes the client to continuously poll the server to obtain the latest data, which will lead to performance and efficiency problems. WebSocket was born to solve these problems.

WebSocket is a new protocol in HTML5. It provides two-way communication and reduces client polling work. The client can send messages directly to the server without waiting for a response from the server. This makes developing real-time applications easier and more efficient.

Java, as a language widely used in web application development, also provides a way to easily implement Websocket. Here's how to use Websockets in Java.

The first step is to import Java’s WebSocket API. You can do this from the Maven central repository or by using the API in the javax.websocket package from the Java EE 7 framework.

The following is an example of implementing Websocket using the API in the javax.websocket package in Java EE 7:

1. Create the ServerEndpoint annotation class

Use The @WebSocket annotation creates a class to tell the Java server that this class can use this session as a WebSocket endpoint and provides a URI to match this address to the WebSocket endpoint.

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
 
@ServerEndpoint(value = "/websocket")
public class WebSocketExample {
     
    @OnOpen
    public void onOpen(){
        System.out.println("Connection opened");
    }
     
    @OnClose
    public void onClose(){
        System.out.println("Connection closed");
    }
     
    @OnMessage
    public void onMessage(String message){
        System.out.println("Message received: " + message);
    }
}

Use the WebSocketExample class as the entrance to our WebSocket program. In the above example, we used the @ServerEndpoint annotation with the Endpoint class to map the class to the specified URI.

@OnOpen, @OnMessage and @OnClose annotations are event-based and are used to specify methods to be called when the WebSocket connection is opened, messages are received and the connection is closed.

The obtained message string will be passed directly to the onMessage callback method. Now, we have defined endpoints on the WebSocket server side.

2. Create client example

public class WebSocketClientExample extends Endpoint {
 
    public static CountDownLatch latch;
 
    @Override
    public void onOpen(final Session session, EndpointConfig config) {
        System.out.println("Connected");
 
        try {
            session.getBasicRemote().sendText("Hello");
        } catch (IOException ex) {
        }
    }
 
    @Override
    public void onError(final Session session, Throwable t) {
        t.printStackTrace();
    }
}

Our WebSocket client can use javax.websocket.Endpoint as the base class, which is part of the WebSocket API.

We will use CountDownLatch to determine whether the client is connected to the server.

In the onOpen() callback method, we have connected to the server and sent the message.

Note: In this example, the message is sent by using the session.getBasicRemote().sendText(“Hello”); method. In the WebSocket API, there is another method for sending messages, namely session.getAsyncRemote().sendText("Hello");. The difference is that the getBasicRemote() method is blocking, while the getAsyncRemote() method is non-blocking. of. If we want to send messages asynchronously, we can use getAsyncRemote().

3. Create a test class and run the application

Build a test class to serve the server and client to ensure the normal establishment of the connection. You need to start the application and let the running application interact with the WebSocket server. If everything is fine, you should see some messages printed on the development tool's console.

import javax.websocket.*;
import java.net.URI;
import java.util.concurrent.CountDownLatch;
 
public class AppRunner {
 
    public static void main(String[] args) throws Exception {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
 
        CountDownLatch latch = new CountDownLatch(1);
 
        container.connectToServer(new WebSocketExample(), new URI("ws://localhost:8080/websocket"));
 
        latch.await();
    }
}

This test code will start the WebSocket client and try to connect to the WebSocket server on localhost:8080. We will use a CountDownLatch object to wait for a successful connection along with some additional information.

When running the test, we can type http://localhost:8080/websocket through a web browser and open the JavaScript console to view and send messages to the WebSocket client through the JavaScript WebSocket object.

Summary:

Using WebSocket for real-time communication is far more efficient than using traditional HTTP periodic polling. In Java language, you can use WebSocket API to implement Websocket. This article provides a Java sample program for WebSocket server and client as well as specific code implementation examples. I hope it will be helpful to readers.

The above is the detailed content of Java Websocket Development Guide: How to achieve real-time communication between client and server. For more information, please follow other related articles on the PHP Chinese website!