Comment Java Websocket implémente-t-il les fonctions de jeu en ligne ?

Java Websocket est un protocole de communication full-duplex basé sur le protocole TCP, qui peut réaliser une communication bidirectionnelle sur une connexion persistante. Cela rend Java Websocket très adapté au développement de jeux en ligne en temps réel, car les jeux nécessitent une interaction rapide et une communication en temps réel.

Dans cet article, nous présenterons comment utiliser Java Websocket pour implémenter des fonctions de jeu en ligne. Nous utiliserons Java 8 et Tomcat 8 comme environnement de développement, et la page frontale utilise HTML5 et JavaScript.

1. Établir une connexion WebSocket

Tout d'abord, nous devons créer une connexion WebSocket. Nous pouvons réaliser cette fonctionnalité en écrivant un point de terminaison WebSocket. Dans une application JavaWeb, nous pouvons configurer le point de terminaison Websocket à l'aide de javax.websocket.Endpoint.

Ce qui suit est l'implémentation du point de terminaison Websocket :

@ServerEndpoint("/game")
public class GameEndpoint {

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("WebSocket Opened: " + session.getId());
        GameSessionManager.getInstance().addSession(session); // 将Session加入管理器
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("WebSocket Message received: " + message);
        GameSessionManager.getInstance().handleMessage(message, session); // 处理消息
    }

    @OnClose
    public void onClose(Session session) {
        System.out.println("WebSocket Closed: " + session.getId());
        GameSessionManager.getInstance().removeSession(session); // 将Session从管理器中移除
    }

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

Dans ce point de terminaison, nous définissons quatre annotations :

• @ServerEndpoint("/game") définit le chemin de ce point de terminaison comme "/game".
• @OnOpen définit ce que fait ce point de terminaison lorsque WebSocket est ouvert, comme l'ajout d'une connexion WebSocket au gestionnaire.
• @OnMessage définit ce que fait ce point de terminaison lorsque WebSocket reçoit un message, comme l'envoi du message à tous les clients WebSocket connectés.
• @OnClose définit ce que fait ce point de terminaison lorsque WebSocket est fermé, comme supprimer la connexion WebSocket du gestionnaire.
• @OnError définit ce que fait ce point de terminaison lorsqu'une erreur WebSocket se produit.

Remarque : Ceci n'est qu'un exemple simple, davantage de gestion des erreurs et de contrôles de sécurité devraient être effectués dans les applications réelles.

2. Gérer les sessions de jeu

Nous devons créer une classe GameSessionManager pour gérer les sessions de jeu. GameSessionManager est une classe singleton utilisée pour gérer toutes les connexions WebSocket et gérer les messages liés au jeu.

Ce qui suit est l'implémentation de GameSessionManager :

public class GameSessionManager {

    private Set<Session> sessions = new HashSet<>();
    private static GameSessionManager instance;

    private GameSessionManager() {
    }

    public static GameSessionManager getInstance() {
        if (instance == null) {
            synchronized (GameSessionManager.class) {
                if (instance == null) {
                    instance = new GameSessionManager();
                }
            }
        }
        return instance;
    }

    public void addSession(Session session) {
        sessions.add(session);
    }

    public void removeSession(Session session) {
        sessions.remove(session);
    }

    public void handleMessage(String message, Session session) {
        // TODO 处理消息
    }

    public void broadcast(String message) {
        for (Session session : sessions) {
            send(message, session);
        }
    }

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

Dans cette classe, nous créons une collection de sessions pour stocker toutes les sessions WebSocket. Utilisez la méthode getInstance() pour obtenir l'objet singleton de GameSessionManager. Lors de l'ajout et de la suppression de connexions WebSocket, nous ajoutons ou supprimons simplement la connexion à la collection. Lors de la diffusion d'un message, nous parcourons toutes les sessions WebSocket et envoyons le message à chacune d'elles. Lors de l'envoi d'un message, nous utilisons la méthode session.getBasicRemote() pour obtenir le port distant de base, puis appelons la méthode sendText() pour envoyer le message au client.

3. Gestion des messages de jeu

Nous traiterons les messages de jeu du client dans la classe GameSessionManager et les renverrons au client. Nous aborderons également ici la logique du jeu.

Voici un simple jeu de « chat » avec les opérations « bonjour » et « au revoir » comme exemple :

public void handleMessage(String message, Session session) {
    JSONObject json = new JSONObject(message);
    String action = json.getString("action");
    switch (action) {
        case "hello":
            String name = json.optString("name");
            broadcast(name + " joined the game.");
            break;
        case "bye":
            String playerName = json.optString("name");
            broadcast(playerName + " left the game.");
            break;
        default:
            System.out.println("Unknown action: " + action);
            break;
    }
}

Dans cette implémentation, nous analysons d'abord le message reçu au format JSON. Nous vérifions ensuite le champ « Action » du message et effectuons l'action appropriée en fonction des différentes opérations. Si l'action est "bonjour", nous récupérons le nom du joueur à partir du message et utilisons la méthode de diffusion pour envoyer le message de bienvenue à tous les joueurs. Si l'opération est "au revoir", nous obtenons également le nom du joueur à partir du message et utilisons la méthode de diffusion pour envoyer le message d'adieu à tous les joueurs. Sinon, nous imprimons un message pour une opération inconnue.

4. Créer une page front-end

La page front-end est implémentée en utilisant HTML5 et JavaScript. Nous devons écrire une classe JavaScript qui implémente WebSocket. Dans une application JavaWeb, nous pouvons utiliser l'objet WebSocket de JavaScript pour créer une connexion WebSocket.

Voici la classe JavaScript qui implémente WebSocket :

var webSocket = null;
var url = "ws://" + window.location.hostname + ":" + window.location.port + "/game";

function connectWebSocket() {
    if("WebSocket" in window) {
        webSocket = new WebSocket(url);

        webSocket.onopen = function(event) {
            console.log("WebSocket opened.");
        };

        webSocket.onmessage = function(event) {
            console.log("WebSocket message received: " + event.data);
            handleMessage(event.data);
        };

        webSocket.onclose = function(event) {
            console.log("WebSocket closed.");
        };
    } else {
        console.log("WebSocket is not supported by this browser.");
    }
}

function sendMessage(message) {
    if(webSocket) {
        webSocket.send(message);
    } else {
        console.log("WebSocket is not connected.");
    }
}

Dans cette implémentation, nous vérifions d'abord si WebSocket est pris en charge. Si tel est le cas, nous créerons un objet WebSocket à l'aide du constructeur de WebSocket et l'attribuerons à la variable webSocket. Nous avons défini trois gestionnaires d'événements WebSocket :

• websocket.onopen Les opérations effectuées à l'ouverture du WebSocket, comme le lancement d'une demande de connexion au serveur.
• websocket.onmessage définit les opérations effectuées par WebSocket lorsqu'il reçoit un message, comme appeler la fonction handleMessage pour traiter le message.
• websocket.onclose définit ce qu'il faut faire lorsque WebSocket est fermé, comme essayer de se reconnecter.

Nous définissons également une fonction sendMessage, qui utilise la méthode send de l'objet WebSocket pour envoyer le message au serveur.

5. Implémenter l'interaction front-end

Nous utiliserons jQuery pour implémenter l'interaction front-end et envoyer des messages de jeu au serveur.

Ce qui suit est l'implémentation de la fonction handleMessage :

function handleMessage(message) {
    var json = $.parseJSON(message);
    var action = json.action;
    switch (action) {
        case "hello":
            var name = json.name;
            console.log("Player " + name + " joined the game.");
            break;
        case "bye":
            var playerName = json.name;
            console.log("Player " + playerName + " left the game.");
            break;
        default:
            console.log("Unknown action: " + action);
            break;
    }
}

$(document).ready(function() {
    connectWebSocket();

    $("#btnHello").click(function(event) {
        var playerName = $("#txtName").val();
        var message = '{"action": "hello", "name": "' + playerName + '"}';
        sendMessage(message);
    });

    $("#btnBye").click(function(event) {
        var playerName = $("#txtName").val();
        var message = '{"action": "bye", "name": "' + playerName + '"}';
        sendMessage(message);
    });
});

Dans cette implémentation, nous utilisons la fonction $.parseJSON de jQuery pour analyser le message reçu au format JSON. Nous vérifions ensuite le champ « Action » du message et effectuons l'action appropriée en fonction des différentes opérations. Si l'action est "bonjour", nous récupérons le nom du joueur à partir du message et imprimons le message pour rejoindre la partie. Si l'action est "au revoir", nous récupérons également le nom du joueur à partir du message et imprimons le message de sortie du jeu. Sinon, nous imprimons un message pour une opération inconnue.

我们还将为两个按钮分别定义单击事件，这些事件将生成相应的JSON消息并使用'use SendMessage（）函数向服务器发送消息。

6. 测试

现在我们已经完成了Java Websocket实现在线游戏的所有工作。我们需要在Tomcat服务器上启动我们的应用程序并在浏览器中打开前端页面。我们可以使用多个浏览器测试在线游戏的功能。

下面是完整的游戏前端代码，供您参考：

<!doctype html>
<html>
<head>
    <title>WebSocket Chat</title>
    <meta charset="utf-8"/>
    <script src="https://code.jquery.com/jquery-3.5.0.min.js"></script>
    <script src="websockets.js"></script>
    <script>
        $(document).ready(function() {
            connectWebSocket();

            $("#btnHello").click(function(event) {
                var playerName = $("#txtName").val();
                var message = '{"action": "hello", "name": "' + playerName + '"}';
                sendMessage(message);
            });

            $("#btnBye").click(function(event) {
                var playerName = $("#txtName").val();
                var message = '{"action": "bye", "name": "' + playerName + '"}';
                sendMessage(message);
            });
        });

        function handleMessage(message) {
            var json = $.parseJSON(message);
            var action = json.action;
            switch (action) {
                case "hello":
                    var name = json.name;
                    console.log("Player " + name + " joined the game.");
                    break;
                case "bye":
                    var playerName = json.name;
                    console.log("Player " + playerName + " left the game.");
                    break;
                default:
                    console.log("Unknown action: " + action);
                    break;
            }
        }
    </script>
</head>
<body>
    <div>
        <label>Player name:</label>
        <input type="text" id="txtName"/>
        <button id="btnHello">Join game</button>
        <button id="btnBye">Leave game</button>
    </div>
</body>
</html>

结论

这篇文章主要介绍了使用Java Websocket实现在线游戏的过程。我们在Java 8和Tomcat 8中开发了一个简单的“chat”游戏，并使用HTML5和JavaScript实现了前端。我们展示了如何使用WebSocket端点，如何管理游戏会话，如何处理游戏消息，如何与前端进行交互，并提供了完整的代码示例。

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!