Java et WebSockets : comment implémenter une communication de jeu en temps réel-javaDidacticiel-php.cn

Java et WebSockets : comment implémenter une communication de jeu en temps réel

Java et WebSocket : Mise en œuvre de la communication de jeu en temps réel

Introduction :
Avec le développement d'Internet et la popularité des appareils intelligents, la communication de jeu en temps réel est devenue de plus en plus importante. Le protocole HTTP traditionnel présente certaines limites dans la réalisation d'une communication en temps réel, et WebSocket, en tant que protocole de communication en duplex intégral, offre une meilleure solution de communication en temps réel. Cet article présentera comment utiliser Java et WebSocket pour implémenter la communication de jeu en temps réel, avec des exemples de code spécifiques.

1. Introduction à WebSocket
WebSocket est un protocole de communication full-duplex sur une seule connexion TCP. Par rapport au protocole HTTP, WebSocket peut établir une communication bidirectionnelle en temps réel et transmettre des paquets de données plus petits entre le client et le serveur. Le protocole WebSocket utilise un port HTTP standard pour se connecter, permettant au client et au serveur d'établir une connexion via une poignée de main, et une fois la connexion établie, elle peut rester ouverte.

2. Java implémente la communication WebSocket
Java possède de nombreuses bibliothèques qui prennent en charge le protocole WebSocket, telles que l'API Java pour WebSocket, Jetty et Tyrus, etc. Ces bibliothèques fournissent des classes et des méthodes liées à WebSocket, qui peuvent nous aider à implémenter facilement la communication WebSocket.

Ce qui suit est un exemple simple utilisant l'API Java pour 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();
    }
}

Copier après la connexion

Dans l'exemple ci-dessus, nous avons créé une classe WebSocketClient et l'avons annotée avec l'annotation @ClientEndpoint. Cette classe définit des méthodes telles que onOpen, onMessage, onError et onClose, qui représentent respectivement le traitement de rappel lorsque la connexion est établie, qu'un message est reçu, qu'une erreur se produit et que la connexion est fermée. La méthode sendMessage est utilisée pour envoyer des messages. Dans la méthode principale, nous obtenons d'abord le conteneur WebSocket, puis nous nous connectons au serveur via la méthode connectToServer et utilisons sendMessage pour envoyer le message. Enfin, attendez 5 secondes puis fermez la connexion via la méthode Thread.sleep.

3. Exemple de communication de jeu en temps réel
Afin de mieux comprendre comment utiliser Java et WebSocket pour réaliser une communication de jeu en temps réel, nous prenons comme exemple un jeu multijoueur simple "Devinez les énigmes des lanternes".

Code côté serveur

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

Copier après la connexion

Dans l'exemple ci-dessus, nous avons créé une classe WebSocketServer et l'avons annotée avec l'annotation @ServerEndpoint. Cette classe définit des méthodes telles que onOpen, onMessage, onClose et onError, qui représentent respectivement le traitement de rappel lorsque la connexion est établie, qu'un message est reçu, que la connexion est fermée et qu'une erreur se produit. Dans la méthode onOpen, nous ajoutons la connexion nouvellement établie à la collection de sessions ; dans la méthode onMessage, nous parcourons la collection de sessions et envoyons les messages reçus à tous les clients ; dans la méthode onClose, nous supprimons la connexion fermée des sessions supprimées de ; collection.

Code client
```
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();
 }
}
```
Copier après la connexion
Dans l'exemple ci-dessus, nous avons créé une classe WebSocketClient et l'avons annotée avec l'annotation @ClientEndpoint. Cette classe définit des méthodes telles que onOpen, onMessage, onClose et onError, qui représentent respectivement le traitement de rappel lorsque la connexion est établie, qu'un message est reçu, que la connexion est fermée et qu'une erreur se produit. La méthode sendMessage est utilisée pour envoyer des messages. Dans la méthode principale, nous obtenons d'abord le conteneur WebSocket, puis nous nous connectons au serveur via la méthode connectToServer et utilisons sendMessage pour envoyer les messages saisis à partir du clavier. Enfin, l'entrée de l'utilisateur est lue en continu via la méthode scanner.nextLine jusqu'à ce que « exit » soit saisi pour quitter.

Résumé :
Grâce à Java et WebSocket, nous pouvons facilement réaliser une communication de jeu en temps réel. Grâce à la fonctionnalité de communication full-duplex de WebSocket, nous pouvons établir une communication bidirectionnelle en temps réel entre le client et le serveur et transmettre des paquets de données plus petits. Dans cet article, nous implémentons un exemple simple de communication de jeu en temps réel via les classes et méthodes fournies par l'API Java pour la bibliothèque WebSocket. Cet exemple peut être utilisé comme apprentissage et référence pour aider les développeurs à mieux comprendre et appliquer Java et WebSocket pour parvenir à une communication de jeu en temps réel.

Références :
1. Programmation Java WebSocket https://www.baeldung.com/java-websockets
2. Comprendre les WebSockets https://www.ibm.com/support/knowledgecenter/en/SSEQTP_8.5.5/ com. .ibm.websphere.wsrp.doc/info/ae/ae/twbs_understand.html
(Remarque : le code ci-dessus n'est qu'un exemple et peut devoir être modifié et amélioré en fonction des besoins spécifiques de l'entreprise.)
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!