Comment développer des applications Websocket en utilisant Java

WebSocket est un nouveau protocole introduit par HTML5, utilisé pour établir des connexions longues entre clients et serveurs. Comme HTTP, il peut fonctionner sur des ports Web standard, peut également traverser des pare-feu et des serveurs proxy et a été largement utilisé dans des scénarios tels que la communication en temps réel et les notifications push.

En tant que langage de programmation puissant, Java fournit également diverses API et bibliothèques liées à WebSocket. Cet article expliquera comment utiliser Java pour développer des applications Websocket et fournira des exemples de code spécifiques.

1. Introduction à l'API WebSocket

Java EE 7 fournit l'API Java JSR-356 pour WebSocket, qui comprend des interfaces WebSocket côté client et côté serveur. Vous pouvez utiliser des conteneurs Java EE 7 (tels que GlassFish, Tomcat, etc.) ou des bibliothèques tierces (telles que Jetty, Tyrus, etc.) pour implémenter les fonctions WebSocket.

Les interfaces et classes principales de l'API Java WebSocket sont les suivantes :

• Session : représente la session de connexion WebSocket via laquelle les messages peuvent être envoyés et reçus.
• Endpoint : représente le point de terminaison de WebSocket et implémente la logique de base de WebSocket, y compris la connexion, la transmission de messages, la gestion des erreurs, etc.
• MessageHandler : représente le gestionnaire de messages de WebSocket, utilisé pour recevoir et traiter différents types de messages.

Les applications WebSocket peuvent être facilement implémentées à l'aide de l'API Java WebSocket, et nous présenterons ensuite des exemples spécifiques.

2. Exemples d'applications WebSocket

Cet article présentera l'implémentation des applications WebSocket sous les aspects suivants :

• Implémentation du point de terminaison WebSocket côté serveur
• Implémentation de WebSocket côté client
• Implémentation des messages de diffusion côté serveur

2.1 Implémentation du point de terminaison WebSocket côté serveur

Pour implémenter une application WebSocket côté serveur, nous devons créer un point de terminaison WebSocket. Le code simple du point de terminaison est le suivant :

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

@ServerEndpoint(value = "/chat")
public class ChatEndpoint {

    @OnMessage
    public void onMessage(Session session, String message) throws IOException {
        // 处理收到的消息
        session.getBasicRemote().sendText("You said: " + message);
    }
}

Spécifiez le chemin URI du point de terminaison via l'annotation @ServerEndpoint, ici "/chat". Dans le point de terminaison, l'annotation @OnMessage est implémentée pour recevoir et traiter les messages envoyés par le client. Dans cette méthode, nous pouvons traiter le message reçu et envoyer un message de réponse au client.

2.2 Implémentation de WebSocket côté client

Le client peut utiliser l'API client javax.websocket pour implémenter WebSocket via Java Voici un exemple simple de client Java WebSocket :

import javax.websocket.ClientEndpoint;
import javax.websocket.OnMessage;
import javax.websocket.Session;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.CountDownLatch;

@ClientEndpoint
public class ChatClientEndpoint {

    private CountDownLatch latch;

    public ChatClientEndpoint(CountDownLatch latch) {
        this.latch = latch;
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        System.out.println("Received message: " + message);
        latch.countDown();
    }

    public static void main(String[] args) throws Exception {
        final int messageCount = 5;
        final CountDownLatch latch = new CountDownLatch(messageCount);

        URI uri = new URI("ws://localhost:8080/chat");
        ChatClientEndpoint client = new ChatClientEndpoint(latch);

        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        container.connectToServer(client, uri);

        for (int i = 0; i < messageCount; i++) {
            String message = "Hello " + i;
            client.sendMessage(message);
            System.out.println("Sent message: " + message);
        }

        latch.await();
        container.close();
    }

    public void sendMessage(String message) {
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans le code client, nous utilisons l'annotation @ClientEndpoint. Marquez le. le point de terminaison WebSocket du client. Dans la méthode principale, nous utilisons WebSocketContainer pour nous connecter côté serveur et envoyer 5 messages. Après avoir reçu la réponse côté serveur, la méthode onMessage sera appelée pour le traitement et CountDownLatch sera utilisé pour implémenter l'attente synchrone du programme.

2.3 Implémentation de messages diffusés côté serveur

Dans les applications WebSocket, il est parfois nécessaire que le serveur diffuse des messages à tous les clients. Voici un exemple simple :

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

@ServerEndpoint(value = "/chat")
public class ChatEndpoint {

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

    @OnMessage
    public void onMessage(Session session, String message) throws IOException {
        // 处理收到的消息
        broadcast("User " + session.getId() + " said: " + message);
    }

    private void broadcast(String message) throws IOException {
        for (Session session : sessions) {
            if (session.isOpen()) {
                session.getBasicRemote().sendText(message);
            }
        }
    }

    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
    }

    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
    }
}

Dans ce code, nous maintenons une liste de toutes les sessions WebSocket, ajoutons de nouvelles sessions dans la méthode @OnOpen et supprimons des sessions dans la méthode @OnClose. Dans le même temps, les messages de diffusion sont envoyés à toutes les sessions WebSocket dans la méthode de diffusion.

3. Résumé

WebSocket est un nouveau protocole très puissant qui permet aux programmes d'établir une communication en temps réel et des fonctions push en temps réel. Java fournit également une riche prise en charge d'API et de bibliothèques pour WebSocket. Cet article explique comment développer des applications WebSocket à l'aide de Java et donne des exemples de code spécifiques. J'espère que cet article pourra être utile pour développer des applications WebSocket en Java.

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!