So entwickeln Sie Websocket-Anwendungen mit Java

WebSocket ist ein neues Protokoll, das von HTML5 eingeführt wurde und zum Aufbau langer Verbindungen zwischen Clients und Servern verwendet wird. Wie HTTP kann es auf Standard-Webports ausgeführt werden, kann auch Firewalls und Proxyserver passieren und wird häufig in Szenarien wie Echtzeitkommunikation und Push-Benachrichtigungen eingesetzt.

Als leistungsstarke Programmiersprache bietet Java auch verschiedene WebSocket-bezogene APIs und Bibliotheken. In diesem Artikel wird die Verwendung von Java zum Entwickeln von Websocket-Anwendungen vorgestellt und spezifische Codebeispiele bereitgestellt.

1. Einführung in die WebSocket-API

Java EE 7 bietet die JSR-356-Java-API für WebSocket, die clientseitige und serverseitige WebSocket-Schnittstellen umfasst. Sie können Java EE 7-Container (wie GlassFish, Tomcat usw.) oder Bibliotheken von Drittanbietern (wie Jetty, Tyrus usw.) verwenden, um WebSocket-Funktionen zu implementieren.

Die Kernschnittstellen und Klassen der Java WebSocket API sind wie folgt:

• Sitzung: Stellt die WebSocket-Verbindungssitzung dar, über die Nachrichten gesendet und empfangen werden können.
• Endpunkt: Stellt den Endpunkt von WebSocket dar und implementiert die Kernlogik von WebSocket, einschließlich Verbindung, Nachrichtenübertragung, Fehlerbehandlung usw.
• MessageHandler: Stellt den Nachrichtenhandler von WebSocket dar, der zum Empfangen und Verarbeiten verschiedener Arten von Nachrichten verwendet wird.

WebSocket-Anwendungen können einfach mit der Java WebSocket-API implementiert werden, und wir werden als Nächstes konkrete Beispiele vorstellen.

2. WebSocket-Anwendungsbeispiele

In diesem Artikel wird die Implementierung von WebSocket-Anwendungen unter folgenden Gesichtspunkten vorgestellt:

• Serverseitige WebSocket-Endpunktimplementierung
• Clientseitige WebSocket-Implementierung
• Serverseitige Broadcast-Nachrichtenimplementierung

2.1 Serverseitige WebSocket-Endpunktimplementierung

Um eine WebSocket-Anwendung auf der Serverseite zu implementieren, müssen wir einen WebSocket-Endpunkt erstellen. Der einfache Endpunktcode lautet wie folgt:

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

Geben Sie den URI-Pfad des Endpunkts über die Annotation @ServerEndpoint an, hier ist er „/chat“. Im Endpunkt ist die Annotation @OnMessage implementiert, um vom Client gesendete Nachrichten zu empfangen und zu verarbeiten. Bei dieser Methode können wir die empfangene Nachricht verarbeiten und eine Antwortnachricht an den Client senden.

2.2 Clientseitige WebSocket-Implementierung

Der Client kann die javax.websocket-Client-API verwenden, um WebSocket über Java zu implementieren. Hier ist ein einfaches Java-WebSocket-Client-Beispiel:

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

Im Client-Code verwenden wir die Annotation @ClientEndpoint WebSocket-Endpunkt des Clients. In der Hauptmethode verwenden wir WebSocketContainer, um eine Verbindung zur Serverseite herzustellen und 5 Nachrichten zu senden. Nach Erhalt der serverseitigen Antwort wird die onMessage-Methode zur Verarbeitung aufgerufen und CountDownLatch wird verwendet, um das synchrone Warten des Programms zu implementieren.

2.3 Implementierung serverseitiger Broadcast-Nachrichten

In WebSocket-Anwendungen ist es manchmal erforderlich, dass der Server Nachrichten an alle Clients sendet. Hier ist ein einfaches Beispiel:

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

In diesem Code verwalten wir eine Liste aller WebSocket-Sitzungen, fügen neue Sitzungen in der @OnOpen-Methode hinzu und entfernen Sitzungen in der @OnClose-Methode. Gleichzeitig werden Broadcast-Nachrichten im Broadcast-Verfahren an alle WebSocket-Sitzungen gesendet.

3. Zusammenfassung

WebSocket ist ein sehr leistungsfähiges neues Protokoll, das es Programmen ermöglicht, Echtzeitkommunikation und Echtzeit-Push-Funktionen einzurichten. Java bietet außerdem umfangreiche API- und Bibliotheksunterstützung für WebSocket. In diesem Artikel wird erläutert, wie Sie WebSocket-Anwendungen mit Java entwickeln, und es werden konkrete Codebeispiele aufgeführt. Ich hoffe, dass dieser Artikel für die Entwicklung von WebSocket-Anwendungen in Java hilfreich sein kann.

Das obige ist der detaillierte Inhalt vonSo entwickeln Sie Websocket-Anwendungen mit Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!