Comprendre les WebSockets en PHP

Les WebSockets fournissent un canal de communication en temps réel en duplex intégral sur une seule connexion TCP. Contrairement à HTTP, où le client envoie des requêtes au serveur et attend une réponse, les WebSockets permettent une communication continue entre le client et le serveur sans avoir besoin de plusieurs requêtes. Ceci est idéal pour les applications qui nécessitent des mises à jour en temps réel, telles que les applications de chat, les notifications en direct et les jeux en ligne.

Dans ce guide, nous explorerons les WebSockets, leur fonctionnement et comment les implémenter en PHP.

Que sont les WebSockets ?

Les WebSockets permettent une communication interactive entre un navigateur Web (ou tout autre client) et un serveur. Voici les aspects clés des WebSockets :

1. Communication en duplex intégral : le client et le serveur peuvent s'envoyer des messages à tout moment, ce qui rend la connexion plus efficace que l'interrogation HTTP traditionnelle.
2. Connexion persistante : Une fois établie, la connexion WebSocket reste ouverte jusqu'à ce qu'elle soit explicitement fermée par le client ou le serveur.
3. Faible latence : étant donné que les WebSockets éliminent le besoin d'ouvrir de nouvelles connexions pour chaque requête, ils réduisent la latence, ce qui les rend idéaux pour la communication en temps réel.

Comment fonctionnent les WebSockets

1. Handshake : La communication démarre par une requête HTTP. Le client envoie une requête HTTP avec un en-tête Upgrade pour basculer la connexion de HTTP vers WebSockets.
2. Connexion établie : une fois que le serveur reconnaît la prise de contact, la connexion est établie et le client et le serveur peuvent commencer à envoyer et à recevoir des messages.
3. Messagerie : les données sont transmises via des trames légères et peuvent être envoyées dans les deux sens sans la surcharge des en-têtes HTTP.
4. Terminaison de connexion : Le client ou le serveur peut mettre fin à la connexion.

Quand utiliser les WebSockets

• Applications en temps réel : telles que les applications de chat, les notifications en direct et l'édition collaborative.
• Jeux : Pour les jeux multijoueurs en ligne où des mises à jour fréquentes sont nécessaires.
• Flux en direct : diffusion en continu des cours des actions, des résultats sportifs ou des données en temps réel à partir d'appareils IoT.
• Outils de collaboration : pour les applications comme Google Docs où plusieurs utilisateurs doivent voir les mises à jour en temps réel.

Implémentation de WebSockets en PHP

Pour implémenter WebSockets en PHP, vous pouvez utiliser une bibliothèque telle que Ratchet, une bibliothèque PHP spécialement conçue pour la communication bidirectionnelle en temps réel à l'aide de WebSockets.

Implémentation étape par étape de WebSocket à l'aide de Ratchet

Étape 1 : Installer Ratchet via Composer

Tout d'abord, vous devez installer la bibliothèque Ratchet. En supposant que Composer soit installé, vous pouvez exécuter la commande suivante :

composer require cboden/ratchet

Étape 2 : Créer un serveur WebSocket en PHP

Créons un simple serveur WebSocket qui gérera les connexions et les messages.

1. Créez une classe de serveur WebSocket dans WebSocketServer.php :

<?php
use Ratchet\MessageComponentInterface;
use Ratchet\ConnectionInterface;

class WebSocketServer implements MessageComponentInterface {
    protected $clients;

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

    // Called when a new client connects
    public function onOpen(ConnectionInterface $conn) {
        $this->clients->attach($conn);
        echo "New connection: ({$conn->resourceId})\n";
    }

    // Called when a client sends a message
    public function onMessage(ConnectionInterface $from, $msg) {
        echo "New message: $msg\n";

        foreach ($this->clients as $client) {
            if ($from !== $client) {
                // Send the message to everyone except the sender
                $client->send($msg);
            }
        }
    }

    // Called when a connection is closed
    public function onClose(ConnectionInterface $conn) {
        $this->clients->detach($conn);
        echo "Connection closed: ({$conn->resourceId})\n";
    }

    // Called if an error occurs
    public function onError(ConnectionInterface $conn, \Exception $e) {
        echo "Error: {$e->getMessage()}\n";
        $conn->close();
    }
}

Cette classe implémente MessageComponentInterface de Ratchet, qui définit des méthodes de gestion des nouvelles connexions, des messages entrants, des connexions fermées et des erreurs.

Étape 3 : Exécuter le serveur WebSocket

Créez un nouveau script PHP pour démarrer le serveur WebSocket, par exemple start_server.php.

<?php
require __DIR__ . '/vendor/autoload.php';
use Ratchet\Http\HttpServer;
use Ratchet\Server\IoServer;
use Ratchet\WebSocket\WsServer;

$server = IoServer::factory(
    new HttpServer(
        new WsServer(
            new WebSocketServer()
        )
    ),
    8080 // Port number for the WebSocket server
);

$server->run();

Vous pouvez démarrer le serveur en exécutant ce script :

php start_server.php

Le serveur fonctionnera désormais sur ws://localhost:8080.

Étape 4 : Créer un frontend pour se connecter au serveur WebSocket

Maintenant, créons un fichier HTML avec jQuery et JavaScript pour nous connecter au serveur WebSocket.

1. Créez un fichier HTMLindex.html :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Chat</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
    <h2>WebSocket Chat</h2>
    <input type="text" id="message" placeholder="Enter your message">
    <button id="send">Send</button>
    <div id="chat"></div>

    <script>
        $(document).ready(function() {
            var ws = new WebSocket('ws://localhost:8080');

            // When receiving a message from the server
            ws.onmessage = function(event) {
                $('#chat').append('<p>' + event.data + '</p>');
            };

            // Sending a message to the server
            $('#send').click(function() {
                var msg = $('#message').val();
                ws.send(msg);
                $('#message').val('');
            });
        });
    </script>
</body>
</html>

Cette interface simple vous permet de saisir un message et de l'envoyer au serveur WebSocket. Tous les clients connectés recevront le message et l'afficheront.

Étape 5 : Testez la connexion WebSocket

1. Démarrez votre serveur WebSocket en exécutant php start_server.php.
2. Ouvrez index.html dans un navigateur.
3. Ouvrez la même page dans un autre navigateur ou onglet pour simuler plusieurs clients.

Lorsque vous envoyez un message depuis un client, il apparaîtra dans les navigateurs de tous les clients connectés.

Avantages de l'utilisation de WebSockets en PHP

• Mises à jour en temps réel : les WebSockets fournissent des mises à jour en temps réel sans la surcharge des interrogations HTTP.
• Latence inférieure : puisque la connexion reste ouverte, les messages peuvent être envoyés immédiatement, réduisant ainsi la latence.
• Communication bidirectionnelle : le serveur et le client peuvent s'envoyer des messages simultanément, contrairement au HTTP traditionnel où la communication est initiée par le client.

Cas d'utilisation des WebSockets en PHP

• Applications de chat : les WebSockets sont parfaits pour les applications de chat en temps réel où les messages doivent être envoyés instantanément à tous les utilisateurs.
• Notifications en direct : pour les applications qui doivent envoyer des notifications en direct (par exemple, les réseaux sociaux, les cours des actions).
• Outils de collaboration en temps réel : les WebSockets permettent une collaboration en temps réel, comme l'édition de documents en direct.
• Jeux en ligne : les jeux en ligne multijoueurs bénéficient de la communication à faible latence des WebSockets.

Conclusion

Les WebSockets fournissent une solution puissante pour la communication en duplex intégral en temps réel entre le client et le serveur, idéale pour les systèmes de chat, les notifications en direct et d'autres applications en temps réel. En utilisant PHP avec des bibliothèques comme Ratchet, vous pouvez facilement configurer un serveur WebSocket et l'intégrer dans vos applications pour un meilleur engagement et une meilleure réactivité des utilisateurs.

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!