Comment utiliser PHP et WebSocket pour implémenter des fonctions de messagerie instantanée

À l'ère actuelle de développement rapide d'Internet, la demande de messagerie instantanée augmente. Afin de répondre aux besoins des utilisateurs et d’améliorer l’expérience utilisateur, de nombreux sites Web ont intégré des fonctions de messagerie instantanée. Alors, comment utiliser PHP et WebSocket pour implémenter la fonction de messagerie instantanée ? Cet article vous donnera une introduction détaillée aux étapes à suivre pour utiliser PHP et WebSocket pour implémenter les fonctions de messagerie instantanée.

1. Comprendre le protocole WebSocket

WebSocket est un nouveau protocole de communication réseau basé sur le protocole TCP. Il peut réaliser une communication bidirectionnelle entre le client et le serveur, comme celui utilisé dans les scénarios de messagerie instantanée tels que les salons de discussion. Dans le protocole HTTP traditionnel, le client doit obtenir des données en envoyant une requête au serveur, tandis que dans WebSocket, une connexion persistante est établie entre le client et le serveur et les données peuvent être envoyées entre elles à tout moment.

Avant d'utiliser WebSocket pour implémenter des fonctions de messagerie instantanée, vous devez comprendre le protocole WebSocket ainsi que ses avantages et ses inconvénients. Voici quelques avantages du protocole WebSocket :

1 Grâce à une connexion persistante, une communication bidirectionnelle peut être rapidement réalisée et la consommation de bande passante réduite.

2. En réduisant les requêtes HTTP, les performances du serveur peuvent être améliorées.

3. Les tests de compatibilité peuvent être effectués dans différents navigateurs et prennent en charge plusieurs navigateurs.

4. Peut être implémenté via une variété de langages de programmation.

Mais en même temps, le protocole WebSocket présente également quelques défauts :

1. Il n'est pas encore pris en charge par tous les navigateurs grand public. Par exemple, les navigateurs dotés de versions inférieures d'IE ne peuvent pas prendre en charge le protocole WebSocket.

2. En cas d'échec de la connexion WebSocket, le serveur et le client doivent se reconnecter.

3. La sécurité et la confidentialité doivent être assurées pour éviter les fuites de données et autres problèmes.

4. Cela pourrait alourdir le fardeau du système.

2. Comment implémenter WebSocket en PHP

1. Utilisez la bibliothèque Ratchet

Ratchet est une bibliothèque pour PHP permettant d'implémenter le protocole WebSocket. Elle fournit des outils pour le traitement des requêtes HTTP, le serveur et le client WebSockets. Ratchet peut être utilisé dans une variété d'environnements, tels que les frameworks Symfony et Laravel. L'avantage d'utiliser Ratchet est que vous pouvez rapidement implémenter les fonctions WebSocket tout en réduisant les difficultés de développement et la charge de travail des détails sous-jacents.

Voici les étapes pour implémenter WebSocket à l'aide de Ratchet :

(1) Installez la bibliothèque Ratchet

Avant d'utiliser la bibliothèque Ratchet, vous devez installer l'outil Composer sur votre ordinateur. Après avoir installé Composer, installez la bibliothèque Ratchet via l'outil de ligne de commande :

composer require cboden/ratchet

(2) Créez un serveur WebSocket

Après avoir installé la bibliothèque Ratchet, vous devez créer un serveur WebSocket. Voici une simple application Hello World :

<?php
use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;
use MyAppWebSocketApplication;

require __DIR__ . '/vendor/autoload.php';

$server = IoServer::factory(
    new HttpServer(
        new WsServer(
            new WebSocketApplication()
        )
    ),
    8080
);

$server->run();

Dans le code ci-dessus, WebSocketApplication est la classe d'application WebSocket que vous devez écrire vous-même. La création d'une classe d'application WebSocket nécessite l'implémentation de l'interface MessageComponentInterface. La méthode la plus critique est onMessage(), qui est appelée lorsqu'un message client est reçu.

<?php
namespace MyApp;
use RatchetMessageComponentInterface;
use RatchetConnectionInterface;

class WebSocketApplication implements MessageComponentInterface
{
    protected $clients;

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

    public function onOpen(ConnectionInterface $conn) {
        $this->clients->attach($conn);
        echo "New connection! ({$conn->resourceId})
";
    }

    public function onMessage(ConnectionInterface $from, $msg) {
        foreach ($this->clients as $client) {
            if ($from !== $client) {
                $client->send($msg);
            }
        }
    }

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

    public function onError(ConnectionInterface $conn, Exception $e) {
        echo "An error has occurred: {$e->getMessage()}
";
        $conn->close();
    }
}

(3) Testez le serveur WebSocket

Après avoir terminé les étapes ci-dessus, vous pouvez utiliser le client Websocket dans le navigateur pour tester, ou vous pouvez utiliser le client WebSocket dans la ligne de commande pour tester.

2. Utiliser l'extension Swoole

Une autre façon pour PHP d'implémenter le protocole WebSocket consiste à utiliser l'extension Swoole. Swoole est un framework de communication réseau hautes performances qui peut implémenter rapidement les fonctions WebSocket. Il fournit également Coroutine, MySQL asynchrone et d'autres fonctionnalités pour améliorer les performances.

Voici les étapes pour implémenter WebSocket à l'aide de l'extension Swoole :

(1) Installez l'extension Swoole

Vous devez d'abord installer l'extension Swoole sur votre ordinateur. Après avoir installé l'extension Swoole, introduisez la bibliothèque Swoole dans le script PHP :

require "vendor/autoload.php";

(2) Créez un serveur WebSocket

Le code de base pour utiliser Swoole pour implémenter WebSocket est le suivant :

$server = new SwooleWebSocketServer("127.0.0.1", 8080);

$server->on('open', function (SwooleWebSocketServer $server, $request) {
    echo "server: handshake success with fd{$request->fd}
";
});

$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    echo "receive from {$frame->fd}:{$frame->data},opcode:{$frame->opcode},fin:{$frame->finish}
";
    $server->push($frame->fd, "this is server :" . date("Y-m-d H:i:s"));
});

$server->on('close', function ($ser, $fd) {
    echo "client {$fd} closed
";
});

$server->start();

Dans le code ci-dessus, le La méthode est utilisée pour enregistrer les événements d'ouverture, de message, de fermeture et autres. Une fois que le client se connecte au serveur WebSocket, le serveur rappellera l'événement open. Lorsque le client envoie un message, le serveur rappellera l'événement de message pour traiter le message envoyé par le client. A la fin, lorsque le client ferme la connexion WebSocket, le serveur rappellera l'événement de fermeture.

3. Encapsuler la classe d'outils de communication WebSocket

Afin d'améliorer la réutilisabilité du code, nous pouvons encapsuler la fonction de communication WebSocket dans une classe d'outils, afin que d'autres codes puissent facilement implémenter la communication WebSocket en appelant la méthode de classe d'outils.

Ce qui suit est une simple classe utilitaire WebSocket :

<?php
namespace MyApp;

use RatchetClientWebSocket;
use RatchetRFC6455MessagingFrame;
use ReactEventLoopFactory;
use ReactSocketConnector;
use ReactSocketConnectionInterface;

class WebSocketClient
{
    private $client;
    private $loop;

    public function __construct(string $url)
    {
        $this->loop = Factory::create();
        $this->client = new WebSocket($url, [], $this->loop);
    }

    /**
     * @param $data
     * @param int $opcode
     * @param bool $fin
     */
    public function send($data, $opcode = Frame::OP_TEXT, bool $fin = true)
    {
        $this->client->send(new Frame($data, true, $opcode, $fin));
    }

    /**
     * @return WebSocket
     */
    public function getClient(): WebSocket
    {
        return $this->client;
    }

    /**
     * @return ReactEventLoopLoopInterface
     */
    public function getLoop(): ReactEventLoopLoopInterface
    {
        return $this->loop;
    }

    /**
     * @param ConnectionInterface $conn
     */
    public function onClose(ConnectionInterface $conn)
    {
        echo "Connection closed: {$conn->getRemoteAddress()}
";
    }

    public function run()
    {
        $this->client->connect()
            ->then(function (WebSocket $conn) {
                echo "Connected
";
                $this->send('Hello, World!');
                $conn->on('message', function (Frame $msg) use ($conn) {
                    echo "Received: {$msg}
";
                    $conn->close();
                });
                $conn->on('close', function ($code = null, $reason = null) {
                    echo "Connection closed ({$code} - {$reason})
";
                });
            }, function (Throwable $e) {
                echo "Could not connect: {$e->getMessage()}
";
            });

        $this->loop->run();
    }
}

Dans le code ci-dessus, nous définissons la classe WebSocketClient, qui peut créer un client WebSocket et se connecter au serveur spécifié. Dans le même temps, il fournit également des méthodes telles que send et onClose pour envoyer des données et gérer les événements de fermeture de connexion WebSocket. Après avoir créé le client WebSocket, nous avons utilisé le mode Promise pour traiter l'événement de connexion, écouter le message et fermer les événements, et traiter les événements correspondants lorsqu'ils sont déclenchés.

4. Résumé

Cet article vous présente en détail comment utiliser PHP et WebSocket pour implémenter des fonctions de messagerie instantanée, et décrit pour vous les caractéristiques et les lacunes du protocole WebSocket. En utilisant la bibliothèque Ratchet et l'extension Swoole, vous pouvez rapidement implémenter la fonctionnalité WebSocket. Dans le même temps, afin d'améliorer la réutilisabilité de la communication WebSocket, nous vous montrons également comment encapsuler la classe d'outils de communication client WebSocket. J'espère que cet article vous sera utile, merci d'avoir lu.

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!