Utilisation de Websocket pour la communication en temps réel dans le développement d'API Java

Avec le développement continu d'Internet, les exigences en temps réel des applications Web sont de plus en plus élevées. Le protocole HTTP traditionnel ne peut pas répondre aux besoins de communication en temps réel car il s'agit d'une méthode de communication requête-réponse sans état, et la requête et la réponse constituent une connexion unidirectionnelle de courte durée. Ainsi, afin de répondre aux besoins de communication en temps réel, la technologie Websocket est née. Websocket est une technologie de communication en temps réel à connexion longue et full duplex qui permet au client et au serveur d'établir une connexion bidirectionnelle persistante et d'envoyer des données de manière arbitraire pendant le processus de communication.

L'API Java (Application Programming Interface) en tant que langage de développement peut facilement utiliser Websocket pour la communication en temps réel. L'API Java fournit des classes d'outils et des frameworks pour rendre le développement de Websocket plus simple et plus efficace. Cet article expliquera comment utiliser Websocket pour la communication en temps réel dans le développement d'API Java sous les aspects suivants.

1. Utilisation de base de Websocket

L'API Java fournit la norme JSR-356 pour prendre en charge la technologie Websocket dans le langage Java. L'interface Websocket de l'API Java fournit des méthodes de base et des méthodes de gestion des événements liées à Websocket, et les développeurs peuvent utiliser ces méthodes pour implémenter leurs propres serveurs et clients Websocket.

Le développement de programmes Websocket à l'aide de l'API Java nécessite l'annotation javax.websocket.server.ServerEndpoint et l'annotation javax.websocket.OnMessage. Parmi eux, l'annotation @ServerEndpoint est utilisée pour spécifier l'URL, la méthode de codage (telle que UTF-8), le processeur de message (c'est-à-dire WebSocketHandler) et d'autres informations de configuration du service Websocket. L'annotation @OnMessage est utilisée pour déclarer une méthode de traitement de message d'un type spécifié, qui sera appelée lorsque le service Websocket recevra un message envoyé par le client. Lorsque le client envoie un message, le message sera extrait et analysé, puis transmis à la méthode de traitement de message spécifiée pour traitement. Les méthodes de traitement des messages peuvent envoyer des messages de réponse via des objets de session Websocket.

Voici un exemple de code simple :

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

Le code ci-dessus définit un gestionnaire WebSocket nommé WebSocketDemo, lié à l'URL "/test". Lorsque le client envoie un message, la méthode handleMessage de WebSocketDemo sera appelée et un message de réponse sera envoyé.

2. Utilisez Spring Boot pour simplifier le développement de Websocket

Spring Boot est un framework de développement basé sur le framework Spring, et il peut également bien prendre en charge Websocket. En utilisant Spring Boot, il est plus facile d'intégrer la technologie Websocket dans les projets d'API Java, accélérant ainsi le développement d'applications.

Tout d'abord, vous devez ajouter la dépendance suivante dans le fichier pom.xml du projet Spring Boot :

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

Ensuite, vous devez définir la classe WebSocketHandler dans l'application Spring Boot. La classe WebSocketHandler doit hériter de l'interface WebSocketHandler de Spring et implémenter certaines méthodes de base, telles que la méthode handleTextMessage(), pour traiter les messages texte envoyés par le 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)); 
   } 

}

Enfin, WebSocket doit être configuré dans le fichier de configuration de Spring. Application de démarrage. Comme indiqué ci-dessous :

@Configuration 
@EnableWebSocket 
public class WebSocketConfig implements WebSocketConfigurer { 

    @Override 
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { 

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

}

Dans le code ci-dessus, la classe MyHandler sera liée à l'URL "/myHandler" et configurée pour autoriser les requêtes inter-domaines. Vous pouvez implémenter votre propre gestionnaire WebSocket, modifier l'URL ou utiliser d'autres options de configuration. L'utilisation de Spring Boot peut offrir beaucoup de commodité pour le développement de Websocket et simplifier le processus de développement.

3. Utilisez Javascript pour développer le client Websocket

Lorsque nous utilisons l'API Java pour développer le serveur Websocket, nous devons développer le client Websocket pour communiquer avec le serveur. L'API websocket de Javascript nous permet d'utiliser facilement les Websockets pour implémenter la communication client dans les applications Web.

Pour utiliser Websocket en Javascript, vous devez d'abord créer un objet Websocket et spécifier l'adresse du serveur Websocket :

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

Ensuite, vous pouvez utiliser le code suivant pour envoyer un message et recevoir un message de réponse du serveur Websocket :

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

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

Le code ci-dessus se connectera à l'URL en tant que serveur Websocket à l'adresse ws://localhost:8080/test et enverra un message contenant la chaîne "Hello world!" Lorsque le serveur traite le message, il envoie un message de réponse, et finalement le client reçoit le message de réponse et ferme la connexion.

4. Websocket implémente des applications de type salon de discussion

Grâce à l'introduction ci-dessus, je pense que vous avez compris comment utiliser l'API Java pour la programmation Websocket et comment utiliser le client Javascript pour communiquer avec elle. Ensuite, nous pouvons essayer d'utiliser Websocket pour implémenter une simple application de salle de discussion.

Tout d'abord, vous devez utiliser l'API Java pour implémenter un processeur Websocket afin de traiter les messages envoyés par le client Websocket :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!