Using Websocket for real-time communication in Java API development

With the continuous development of the Internet, the real-time requirements of Web applications are getting higher and higher. The traditional HTTP protocol cannot meet the needs of real-time communication because it is a stateless request-response communication method, and the request and response are a one-way short-lived connection. Therefore, in order to meet the needs of real-time communication, Websocket technology was born. Websocket is a full-duplex, long-connection, real-time communication technology that allows the client and server to establish a persistent two-way connection and send data arbitrarily during the communication process.

Java API (Application Programming Interface) as a development language can easily use Websocket for real-time communication. The Java API provides some tool classes and frameworks to make Websocket development simpler and more efficient. This article will introduce how to use Websocket for real-time communication in Java API development from the following aspects.

1. Basic use of Websocket

Java API provides the JSR-356 standard for supporting Websocket technology in the Java language. The Websocket interface in the Java API provides basic methods and event handling methods related to Websocket, and developers can use these methods to implement their own Websocket servers and clients.

Using Java API to develop Websocket programs requires the javax.websocket.server.ServerEndpoint annotation and javax.websocket.OnMessage annotation. Among them, the @ServerEndpoint annotation is used to specify the URL, encoding method (such as UTF-8), message processor (ie WebSocketHandler) and other configuration information of the Websocket service. The @OnMessage annotation is used to declare a message processing method of a specified type, which will be called when the Websocket service receives a message sent by the client. When the client sends a message, the message will be extracted and parsed, and then passed to the specified message processing method for processing. Message processing methods can send response messages through Websocket Session objects.

The following is a simple sample code:

@ServerEndpoint(value = "/test")
public class WebSocketDemo {

    @OnMessage
    public String handleMessage(String message, Session session) {
        System.out.println("Received message: " + message);
        String echoMsg = "Echo from server: " + message;

        // 发送响应消息
        try {
            session.getBasicRemote().sendText(echoMsg);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return echoMsg;
    }
}

The above code defines a WebSocket processor named WebSocketDemo, bound to the URL "/test". When the client sends a message, WebSocketDemo's handleMessage method will be called and a response message will be sent.

2. Use Spring Boot to simplify Websocket development

Spring Boot is a development framework based on the Spring framework, and it can also support Websocket well. By using Spring Boot, it is easier to integrate Websocket technology into Java API projects, thus accelerating application development.

First, you need to add the following dependencies in the pom.xml file of the Spring Boot project:

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

Then, you need to define the WebSocketHandler class in the Spring Boot application. The WebSocketHandler class needs to inherit from Spring's WebSocketHandler interface and implement some basic methods, such as the handleTextMessage() method, for processing text messages sent by the client:

public class MyHandler extends TextWebSocketHandler {

   @Override
   public void handleTextMessage(WebSocketSession session, TextMessage message) 
           throws InterruptedException, IOException { 

        String payload = message.getPayload(); 

        // 处理消息
        String echoMsg = "Echo from server: " + payload;

        // 发送响应消息
        session.sendMessage(new TextMessage(echoMsg)); 
   } 

}

Finally, it needs to be in the configuration file of the Spring Boot application Configure WebSocket in as follows:

@Configuration 
@EnableWebSocket 
public class WebSocketConfig implements WebSocketConfigurer { 

    @Override 
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { 

        registry.addHandler(new MyHandler(), "/myHandler").setAllowedOrigins("*"); 
   } 

}

In the above code, the MyHandler class will be bound to the URL "/myHandler" and set to allow cross-domain requests. You can implement your own WebSocket handler, modify the URL, or use other configuration options. Using Spring Boot can provide a lot of convenience for Websocket development and simplify the development process.

3. Use Javascript to develop Websocket client

While using Java API to develop Websocket server, we need to develop Websocket client to communicate with the server. Javascript's websocket API allows us to easily use Websockets to implement client communication in web applications.

To use Websocket in Javascript, you first need to create a Websocket object and specify the Websocket server address:

var ws = new WebSocket("ws://localhost:8080/test");

Then, you can use the following code to send a message and receive a response message from the Websocket server:

ws.onopen = function() {
   alert("Websocket连接已建立！");
   ws.send("Hello world!");
}; 

ws.onmessage = function(evt) {
   var receivedMsg = evt.data;
   alert("Received message: " + receivedMsg);
   ws.close();
};

The above code will connect to the Websocket server with the URL ws://localhost:8080/test and send a message containing the string "Hello world!". When the server processes the message, it sends a response message, and eventually the client receives the response message and closes the connection.

4. Websocket implements chat room-like applications

Through the above introduction, I believe you have understood how to use Java API for Websocket programming and how to use Javascript client to communicate with it. Next, we can try to use Websocket to implement a simple chat room application.

First, you need to use Java API to implement a Websocket processor to process messages sent by the Websocket client:

@ServerEndpoint(value = "/chat/{username}")
public class ChatServer {

    private static Set<Session> clients = Collections.synchronizedSet(new HashSet<>());

    @OnOpen
    public void onOpen(Session session, @PathParam("username") String username) {
        // 将用户加入到聊天室中
        clients.add(session);

        // 广播消息
        broadcast(username, " joined the chat room!");
    }

    @OnMessage
    public void onMessage(String message, Session session, @PathParam("username") String username) {
        // 广播消息
        broadcast(username, ": " + message);
    }

    @OnClose
    public void onClose(Session session, @PathParam("username") String username) {
        // 将用户从聊天室中移除
        clients.remove(session);

        // 广播消息
        broadcast(username, " left the chat room!");
    }

    private static void broadcast(String username, String message) {
        // 向所有用户广播消息
        for (Session client : clients) {
            try {
                client.getBasicRemote().sendText(username + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码定义了一个名为 ChatServer 的 Websocket 处理器，绑定到 URL “/chat/{username}”。当客户端连接到聊天室时，ChatServer 的 onOpen 方法将被调用，并将客户端添加到 clients 集合中，然后广播一条 “加入聊天室” 的消息。当客户端在聊天室中发送一条消息时，ChatServer 的 onMessage 方法将被调用，并向聊天室的所有客户端广播一条消息。当客户端离开聊天室时，ChatServer 的 onClose 方法将被调用，并将客户端从 clients 集合中移除，然后广播一条 “离开聊天室” 的消息。

然后，需要使用简单的 HTML 和 Javascript 代码实现一个 Websocket 客户端：

<!DOCTYPE html>
<html>
<head>
   <title>Chat room</title>
</head>
<body>
   <h1>Chat room</h1>
   <div id="messageArea"></div>
   <form>
       <input type="text" id="inputField" onkeydown="return send(event)">
   </form>

   <script>
       var ws = new WebSocket("ws://localhost:8080/chat/"+prompt("Please enter your name:"));

       ws.onmessage = function(evt) {
           var receivedMsg = evt.data;
           var messageArea = document.getElementById("messageArea");
           messageArea.innerHTML += receivedMsg + "<br>";
       };

       function send(event) {
           if (event.keyCode == 13) {
               event.preventDefault();
               var inputField = document.getElementById("inputField")
               ws.send(inputField.value);
               inputField.value = "";
               return false;
           }
       }
   </script>
</body>
</html>

以上代码将会要求用户输入他们的名称，然后使用 Websocket 连接到 ChatServer 上。用户可以在输入框中输入文本并按下回车键进行发送。当接收到来自 ChatServer 的消息时，HTML 页面将在聊天窗口底部添加一条新的消息。

通过使用 Java API 和 Websocket 技术，我们可以方便地实现高效、实时的 Web 应用程序。无论你是在开发聊天室、在线游戏还是其他实时 Web 应用程序，Websocket 都可以是一个很好的选择。现在开始尝试使用 Websocket，构建自己的实时 Web 应用程序吧！

The above is the detailed content of Using Websocket for real-time communication in Java API development. For more information, please follow other related articles on the PHP Chinese website!