Java und WebSockets: So implementieren Sie Echtzeit-Spielkommunikation

Java und WebSocket: Implementierung der Echtzeit-Spielkommunikation

Einführung:
Mit der Entwicklung des Internets und der Popularität intelligenter Geräte ist die Echtzeit-Spielkommunikation immer wichtiger geworden. Das herkömmliche HTTP-Protokoll weist einige Einschränkungen bei der Realisierung der Echtzeitkommunikation auf, und WebSocket bietet als Vollduplex-Kommunikationsprotokoll eine bessere Echtzeitkommunikationslösung. In diesem Artikel wird anhand konkreter Codebeispiele erläutert, wie Sie mit Java und WebSocket Echtzeit-Spielkommunikation implementieren.

1. Einführung in WebSocket
WebSocket ist ein Protokoll für die Vollduplex-Kommunikation über eine einzelne TCP-Verbindung. Im Vergleich zum HTTP-Protokoll kann WebSocket eine bidirektionale Kommunikation in Echtzeit erreichen und kleinere Datenpakete zwischen dem Client und dem Server übertragen. Das WebSocket-Protokoll verwendet für die Verbindung einen Standard-HTTP-Port, sodass Client und Server über einen Handshake eine Verbindung herstellen können. Sobald die Verbindung hergestellt ist, kann sie geöffnet bleiben.

2. Java implementiert die WebSocket-Kommunikation
Java verfügt über viele Bibliotheken, die das WebSocket-Protokoll unterstützen, wie z. B. die Java-API für WebSocket, Jetty und Tyrus usw. Diese Bibliotheken stellen WebSocket-bezogene Klassen und Methoden bereit, die uns bei der einfachen Implementierung der WebSocket-Kommunikation helfen können.

Das Folgende ist ein einfaches Beispiel für die Verwendung der Java-API für WebSocket:

import javax.websocket.*;
import java.net.URI;

@ClientEndpoint
public class WebSocketClient {
    Session session;

    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
    }

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

    @OnError
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @OnClose
    public void onClose() {
        System.out.println("Connection closed");
    }

    public void sendMessage(String message) {
        session.getAsyncRemote().sendText(message);
    }

    public static void main(String[] args) throws Exception {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        String uri = "ws://localhost:8080/websocket";
        container.connectToServer(WebSocketClient.class, URI.create(uri));

        WebSocketClient client = new WebSocketClient();

        client.sendMessage("Hello, server!");

        Thread.sleep(5000);

        client.session.close();
    }
}

Im obigen Beispiel haben wir eine WebSocketClient-Klasse erstellt und sie mit der Annotation @ClientEndpoint versehen. Diese Klasse definiert Methoden wie onOpen, onMessage, onError und onClose, die jeweils die Rückrufverarbeitung darstellen, wenn die Verbindung hergestellt wird, eine Nachricht empfangen wird, ein Fehler auftritt und die Verbindung geschlossen wird. Die sendMessage-Methode wird zum Senden von Nachrichten verwendet. In der Hauptmethode rufen wir zunächst den WebSocket-Container ab, stellen dann über die connectToServer-Methode eine Verbindung zum Server her und verwenden sendMessage zum Senden der Nachricht. Warten Sie abschließend 5 Sekunden und schließen Sie dann die Verbindung über die Thread.sleep-Methode.

3. Beispiel für eine Echtzeit-Spielkommunikation
Um besser zu verstehen, wie man mit Java und WebSocket eine Echtzeit-Spielkommunikation erreicht, nehmen wir als Beispiel ein einfaches Multiplayer-Spiel „Guessing Lantern Riddles“.

1. Serverseitiger Code

   import javax.websocket.*;
   import javax.websocket.server.ServerEndpoint;
   import java.io.IOException;
   import java.util.Collections;
   import java.util.HashSet;
   import java.util.Set;
   
   @ServerEndpoint("/websocket")
   public class WebSocketServer {
    private static Set<Session> sessions = Collections.synchronizedSet(new HashSet<>());
   
    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
    }
   
    @OnMessage
    public void onMessage(Session session, String message) throws IOException {
        for (Session s : sessions) {
            s.getBasicRemote().sendText(message);
        }
    }
   
    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
    }
   
    @OnError
    public void onError(Throwable t) {
        t.printStackTrace();
    }
   }

Im obigen Beispiel haben wir eine WebSocketServer-Klasse erstellt und sie mit der Annotation @ServerEndpoint versehen. Diese Klasse definiert Methoden wie onOpen, onMessage, onClose und onError, die jeweils die Rückrufverarbeitung darstellen, wenn die Verbindung hergestellt, eine Nachricht empfangen, die Verbindung geschlossen und ein Fehler auftritt. In der onOpen-Methode fügen wir die neu hergestellte Verbindung zur Sitzungssammlung hinzu. In der onMessage-Methode durchlaufen wir die Sitzungssammlung und senden die empfangenen Nachrichten an alle Clients. In der onClose-Methode entfernen wir die geschlossene Verbindung aus den Sitzungen Sammlung.

2. Client-Code

   import javax.websocket.*;
   import java.io.IOException;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.Scanner;
   
   @ClientEndpoint
   public class WebSocketClient {
    Session session;
   
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
    }
   
    @OnMessage
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }
     
    @OnError
    public void onError(Throwable t) {
        t.printStackTrace();
    }
     
    @OnClose
    public void onClose() {
        System.out.println("Connection closed");
    }
   
    public void sendMessage(String message) {
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
     
    public static void main(String[] args) throws URISyntaxException {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        String uri = "ws://localhost:8080/websocket";
        container.connectToServer(WebSocketClient.class, new URI(uri));
      
        WebSocketClient client = new WebSocketClient();
      
        System.out.println("Enter your message (type 'exit' to quit):");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("exit")) {
                break;
            }
            client.sendMessage(input);
        }
      
        client.session.close();
    }
   }

Im obigen Beispiel haben wir eine WebSocketClient-Klasse erstellt und sie mit der Annotation @ClientEndpoint versehen. Diese Klasse definiert Methoden wie onOpen, onMessage, onClose und onError, die jeweils die Rückrufverarbeitung darstellen, wenn die Verbindung hergestellt, eine Nachricht empfangen, die Verbindung geschlossen und ein Fehler auftritt. Die sendMessage-Methode wird zum Senden von Nachrichten verwendet. Bei der Hauptmethode rufen wir zunächst den WebSocket-Container ab, stellen dann über die connectToServer-Methode eine Verbindung zum Server her und verwenden sendMessage, um über die Tastatur eingegebene Nachrichten zu senden. Schließlich wird die Eingabe des Benutzers kontinuierlich durch die Methode scanner.nextLine gelesen, bis „exit“ zum Beenden eingegeben wird.

Zusammenfassung:
Durch Java und WebSocket können wir problemlos Echtzeit-Spielkommunikation erreichen. Durch die Vollduplex-Kommunikationsfunktion von WebSocket können wir eine bidirektionale Echtzeitkommunikation zwischen dem Client und dem Server erreichen und kleinere Datenpakete weiterleiten. In diesem Artikel implementieren wir ein einfaches Beispiel für die Echtzeit-Spielkommunikation mithilfe der Klassen und Methoden, die von der Java-API für die WebSocket-Bibliothek bereitgestellt werden. Dieses Beispiel kann als Lern- und Referenzbeispiel verwendet werden, um Entwicklern dabei zu helfen, Java und WebSocket besser zu verstehen und anzuwenden, um eine Echtzeit-Spielkommunikation zu erreichen.

Referenzen:

1. Java WebSocket-Programmierung. https://www.baeldung.com/java-websockets
2. WebSockets verstehen .ibm.websphere.wsrp.doc/info/ae/ae/twbs_understand.html

(Hinweis: Der obige Code ist nur ein Beispiel und muss möglicherweise je nach spezifischen Geschäftsanforderungen geändert und verbessert werden.)

Das obige ist der detaillierte Inhalt vonJava und WebSockets: So implementieren Sie Echtzeit-Spielkommunikation. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!