Verwendung von Websocket für die Echtzeitkommunikation in der Java-API-Entwicklung

Mit der kontinuierlichen Weiterentwicklung des Internets werden die Echtzeitanforderungen von Webanwendungen immer höher. Das herkömmliche HTTP-Protokoll kann die Anforderungen der Echtzeitkommunikation nicht erfüllen, da es sich um eine zustandslose Anforderungs-Antwort-Kommunikationsmethode handelt und Anforderung und Antwort eine einseitige, kurzlebige Verbindung darstellen. Um den Anforderungen der Echtzeitkommunikation gerecht zu werden, wurde daher die Websocket-Technologie geboren. Websocket ist eine Vollduplex-Echtzeitkommunikationstechnologie mit langer Verbindung, die es Client und Server ermöglicht, während des Kommunikationsprozesses eine dauerhafte bidirektionale Verbindung aufzubauen und Daten beliebig zu senden.

Java API (Application Programming Interface) als Entwicklungssprache kann Websocket problemlos für die Echtzeitkommunikation verwenden. Die Java-API stellt einige Toolklassen und Frameworks bereit, um die Websocket-Entwicklung einfacher und effizienter zu gestalten. In diesem Artikel wird unter folgenden Aspekten erläutert, wie Websocket für die Echtzeitkommunikation in der Java-API-Entwicklung verwendet wird.

1. Grundlegende Verwendung von Websocket

Die Java-API stellt den JSR-356-Standard zur Unterstützung der Websocket-Technologie in der Java-Sprache bereit. Die Websocket-Schnittstelle in der Java-API stellt grundlegende Methoden und Ereignisbehandlungsmethoden im Zusammenhang mit Websocket bereit, und Entwickler können diese Methoden verwenden, um ihre eigenen Websocket-Server und -Clients zu implementieren.

Für die Entwicklung von Websocket-Programmen mithilfe der Java-API sind die Annotationen javax.websocket.server.ServerEndpoint und javax.websocket.OnMessage erforderlich. Unter anderem wird die Annotation @ServerEndpoint verwendet, um die URL, die Codierungsmethode (z. B. UTF-8), den Nachrichtenprozessor (z. B. WebSocketHandler) und andere Konfigurationsinformationen des Websocket-Dienstes anzugeben. Die Annotation @OnMessage wird verwendet, um eine Nachrichtenverarbeitungsmethode eines bestimmten Typs zu deklarieren, die aufgerufen wird, wenn der Websocket-Dienst eine vom Client gesendete Nachricht empfängt. Wenn der Client eine Nachricht sendet, wird die Nachricht extrahiert und analysiert und dann zur Verarbeitung an die angegebene Nachrichtenverarbeitungsmethode übergeben. Nachrichtenverarbeitungsmethoden können Antwortnachrichten über Websocket-Sitzungsobjekte senden.

Hier ist ein einfacher Beispielcode:

@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;
    }
}

Der obige Code definiert einen WebSocket-Handler namens WebSocketDemo, der an die URL „/test“ gebunden ist. Wenn der Client eine Nachricht sendet, wird die handleMessage-Methode von WebSocketDemo aufgerufen und eine Antwortnachricht gesendet.

2. Verwenden Sie Spring Boot, um die Websocket-Entwicklung zu vereinfachen.

Spring Boot ist ein Entwicklungsframework, das auf dem Spring-Framework basiert und auch Websocket gut unterstützen kann. Durch die Verwendung von Spring Boot ist es einfacher, die Websocket-Technologie in Java-API-Projekte zu integrieren und so die Anwendungsentwicklung zu beschleunigen.

Zuerst müssen Sie die folgende Abhängigkeit in der pom.xml-Datei des Spring Boot-Projekts hinzufügen:

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

Dann müssen Sie die WebSocketHandler-Klasse in der Spring Boot-Anwendung definieren. Die WebSocketHandler-Klasse muss von der WebSocketHandler-Schnittstelle von Spring erben und einige grundlegende Methoden implementieren, z. B. die handleTextMessage()-Methode, um vom Client gesendete Textnachrichten zu verarbeiten:

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)); 
   } 

}

Abschließend muss WebSocket in der Konfigurationsdatei von Spring konfiguriert werden Boot-Anwendung. Wie unten gezeigt:

@Configuration 
@EnableWebSocket 
public class WebSocketConfig implements WebSocketConfigurer { 

    @Override 
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { 

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

}

Im obigen Code wird die MyHandler-Klasse an die URL „/myHandler“ gebunden und so eingestellt, dass sie domänenübergreifende Anforderungen zulässt. Sie können Ihren eigenen WebSocket-Handler implementieren, die URL ändern oder andere Konfigurationsoptionen verwenden. Die Verwendung von Spring Boot kann die Websocket-Entwicklung erheblich vereinfachen und den Entwicklungsprozess vereinfachen.

3. Verwenden Sie Javascript, um den Websocket-Client zu entwickeln.

Während wir die Java-API verwenden, um den Websocket-Server zu entwickeln, müssen wir einen Websocket-Client entwickeln, um mit dem Server zu kommunizieren. Die Websocket-API von Javascript ermöglicht uns die einfache Verwendung von Websockets zur Implementierung der Client-Kommunikation in Webanwendungen.

Um Websocket in Javascript zu verwenden, müssen Sie zunächst ein Websocket-Objekt erstellen und die Websocket-Serveradresse angeben:

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

Anschließend können Sie den folgenden Code verwenden, um eine Nachricht zu senden und eine Antwortnachricht vom Websocket-Server zu empfangen:

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

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

Der obige Code stellt eine Verbindung zur URL als Websocket-Server unter ws://localhost:8080/test her und sendet eine Nachricht mit der Zeichenfolge „Hallo Welt!“ Wenn der Server die Nachricht verarbeitet, sendet er eine Antwortnachricht, und schließlich empfängt der Client die Antwortnachricht und schließt die Verbindung.

4. Websocket implementiert Chatroom-ähnliche Anwendungen

Durch die obige Einführung glaube ich, dass Sie verstanden haben, wie man die Java-API für die Websocket-Programmierung verwendet und wie man mit dem Javascript-Client kommuniziert. Als nächstes können wir versuchen, mit Websocket eine einfache Chatroom-Anwendung zu implementieren.

Zuerst müssen Sie die Java-API verwenden, um einen Websocket-Prozessor zu implementieren, um vom Websocket-Client gesendete Nachrichten zu verarbeiten:

@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 应用程序吧！

Das obige ist der detaillierte Inhalt vonVerwendung von Websocket für die Echtzeitkommunikation in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!