Comment utiliser l'API WebSockets pour la communication en temps réel en PHP

L'API WebSockets est un nouveau protocole d'interaction en temps réel sur les pages Web. Son plus grand avantage est qu'il peut réaliser une communication bidirectionnelle, permettant une communication en temps réel entre le serveur et le client. En PHP, nous pouvons utiliser la bibliothèque Ratchet pour implémenter les fonctionnalités des WebSockets. Cet article présentera en détail comment utiliser l'API WebSockets en PHP pour établir une communication en temps réel.

1. Installez la bibliothèque Ratchet

Avant de commencer à implémenter la fonction WebSockets, nous devons installer la bibliothèque Ratchet. La bibliothèque Ratchet est un serveur WebSockets implémenté en PHP, qui peut nous aider à implémenter rapidement les fonctions WebSockets. Il est très pratique d'installer la bibliothèque Ratchet via Composer. Il suffit d'exécuter la commande suivante dans le répertoire du projet :

composer require cboden/ratchet

2. Créer un serveur WebSockets

Après avoir installé la bibliothèque Ratchet, nous pouvons créer un serveur WebSockets. En PHP, implémentez un serveur WebSockets en créant une classe qui hérite de RatchetServerIoServer. Nous devons d'abord introduire la bibliothèque Ratchet, puis créer une classe nommée WebSocketServer et générer une instance de serveur WebSocket.

use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;

class WebSocketServer {
    public function __construct() {
        $server = IoServer::factory(
            new HttpServer(
                new WsServer(
                    new Chat()
                )
            ),
            8080
        );
        $server->run();
    }
}

Dans le code ci-dessus, nous avons créé une instance de serveur WebSocket et l'avons exécutée sur le port 8080. Avant que le serveur WebSockets ne s'exécute, nous devons créer une classe nommée Chat pour implémenter la logique métier du serveur. La classe Chat sera utilisée pour gérer des opérations telles que la connexion client, la déconnexion et la réception de messages.

3. Gérer la connexion et la déconnexion du client

Ensuite, nous devons implémenter les opérations de connexion, de déconnexion et de réception de messages dans la classe Chat. Lorsque le client se connecte, nous devons le connecter et lui envoyer un message de bienvenue. Lorsque le client se déconnecte, nous devons le supprimer de l'enregistrement. Voici le code qui gère les connexions et déconnexions client :

use RatchetMessageComponentInterface;
use RatchetConnectionInterface;

class Chat implements MessageComponentInterface {
    protected $clients;

    public function __construct() {
        $this->clients = new SplObjectStorage();
    }

    public function onOpen(ConnectionInterface $conn) {
        $this->clients->attach($conn);
        echo "New client connected: {$conn->resourceId}
";
        $conn->send("Welcome!
");
    }

    public function onClose(ConnectionInterface $conn) {
        $this->clients->detach($conn);
        echo "Client disconnected: {$conn->resourceId}
";
    }
}

Dans le code ci-dessus, dans le constructeur de la classe Chat, nous créons un objet SplObjectStorage nommé clients pour stocker toutes les connexions client. Dans la méthode onOpen, lorsqu'un client se connecte, nous le stockons dans les clients et envoyons un message de bienvenue au client. Dans la méthode onClose, lorsqu'un client se déconnecte, nous le supprimons des clients.

4. Traitement de l'envoi et de la diffusion des messages

Une fois le traitement logique de la connexion et de la déconnexion du client terminé, nous devons implémenter la logique de réception, d'envoi et de diffusion des messages. Dans la classe Chat, nous devons implémenter la méthode onMessage pour gérer les messages reçus et envoyer différents messages à l'expéditeur et aux autres clients.

public function onMessage(ConnectionInterface $from, $msg) {
    $data = json_decode($msg);
    $numRecv = count($this->clients) - 1;
    if ($data->type === 'message') {
        foreach ($this->clients as $client) {
            if ($client !== $from) {
                // The sender is not the receiver, send to each client connected
                $client->send(json_encode([
                    'type' => 'message',
                    'user' => $data->user,
                    'message' => $data->message
                ]));
            } else {
                $from->send(json_encode([
                    'type' => 'message',
                    'user' => 'You',
                    'message' => $data->message
                ]));
            }
        }
    }
}

Dans le code ci-dessus, nous analysons d'abord le message reçu et effectuons différents traitements en fonction des différents types de messages. Lorsque le type de message est message, nous devons diffuser un message à tous les clients. Si l'expéditeur n'est pas le destinataire, des messages distincts sont envoyés au destinataire et à l'expéditeur.

Enfin, nous devons instancier la classe Chat dans la classe WebSocketServer et démarrer le serveur WebSockets :

new WebSocketServer();

Grâce aux étapes ci-dessus, nous avons utilisé avec succès la bibliothèque Ratchet pour implémenter la communication en temps réel avec la fonction WebSockets. se connecter à WebSockets via JavaScript Le serveur envoie et reçoit des messages, où JavaScript côté client peut être implémenté à l'aide de l'API WebSockets. Ceci ne sera pas expliqué en détail ici.

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!