PHP développe la notification de diffusion et l'abonnement aux messages du système de chat en temps réel

PHP développe des notifications de diffusion et des abonnements aux messages pour les systèmes de chat en temps réel

Dans les réseaux sociaux et les applications de messagerie instantanée modernes, les systèmes de chat en temps réel sont sans aucun doute une fonction très importante. Les utilisateurs peuvent communiquer avec d'autres utilisateurs en temps réel via ce système, envoyer des messages, recevoir des messages et effectuer des notifications de diffusion et des abonnements aux messages correspondants. Cet article présentera comment utiliser PHP pour développer les fonctions de notification de diffusion et d'abonnement aux messages du système de discussion en temps réel, et fournira des exemples de code correspondants.

Tout d'abord, nous devons envisager une méthode de mise en œuvre réalisable pour garantir un effet de communication en temps réel. Une méthode d'implémentation courante consiste à utiliser le protocole WebSocket, qui fournit un canal de connexion persistant, qui permet au serveur de transmettre activement des messages au client, et le client peut également envoyer des messages au serveur. Basé sur le protocole WebSocket, nous pouvons utiliser PHP pour développer un système de chat en temps réel.

Ensuite, apprenons à utiliser PHP pour implémenter la fonction de notification de diffusion. La notification de diffusion fait référence à la fonction du serveur qui diffuse ou envoie des messages à tous les clients. En PHP, on peut utiliser la bibliothèque Ratchet pour faire fonctionner le protocole WebSocket. Ratchet est une bibliothèque WebSocket implémentée en PHP qui peut facilement interagir avec les serveurs WebSocket.

Tout d'abord, nous devons installer la bibliothèque Ratchet, qui peut être installée à l'aide de composer, en utilisant la commande suivante :

composer require cboden/ratchet

Ensuite, nous pouvons écrire un script PHP pour implémenter le serveur WebSocket et gérer la fonction de notification de diffusion. L'exemple de code est le suivant :

require 'vendor/autoload.php';

use RatchetMessageComponentInterface;
use RatchetConnectionInterface;
use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;

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 . PHP_EOL;
    }
    
    public function onMessage(ConnectionInterface $from, $msg)
    {
        foreach ($this->clients as $client) {
            $client->send($msg);
        }
    }
    
    public function onClose(ConnectionInterface $conn)
    {
        $this->clients->detach($conn);
        echo "Client disconnected: " . $conn->resourceId . PHP_EOL;
    }
    
    public function onError(ConnectionInterface $conn, Exception $e)
    {
        echo "An error has occurred: " . $e->getMessage() . PHP_EOL;
        $conn->close();
    }
}

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

$server->run();

Le code ci-dessus crée une classe Chat, implémente l'interface MessageComponentInterface et remplace les méthodes associées. La méthode onOpen est appelée lorsque le client se connecte, la méthode onMessage est appelée lorsqu'un message client est reçu, la méthode onClose est appelée lorsque le client se déconnecte et la méthode onError est appelée lorsqu'une erreur se produit.

Dans la méthode onMessage, nous implémentons la fonction de notification de diffusion en parcourant tous les clients et en envoyant le message reçu à chaque client.

En exécutant le code ci-dessus, nous créons un serveur WebSocket capable d'écouter le port 8080 et d'attendre les connexions. Lorsqu'un nouveau client se connecte, le serveur affichera les informations correspondantes, et lorsqu'un client se déconnectera, il affichera également les informations correspondantes.

Ensuite, apprenons à utiliser PHP pour implémenter la fonction d'abonnement aux messages. L'abonnement aux messages fait référence au client qui s'abonne à une chaîne ou à un sujet spécifique. Lorsqu'il y a de nouveaux messages dans la chaîne, le client peut recevoir les messages en temps réel. Afin d'implémenter la fonction d'abonnement aux messages, nous pouvons utiliser Redis comme file d'attente de messages pour enregistrer et envoyer des messages.

Tout d'abord, nous devons installer et configurer Redis. Vous pouvez vous référer à la documentation officielle de Redis pour l'installation et la configuration.

Ensuite, nous devons utiliser la bibliothèque de connexion Redis pour implémenter la fonction d'abonnement aux messages. Vous pouvez utiliser la bibliothèque Predis, qui est une bibliothèque de classes PHP Redis populaire. Utilisez la commande suivante pour installer la bibliothèque Predis :

composer require predis/predis

Nous avons toujours besoin d'un serveur WebSocket pour écouter les connexions client et gérer les fonctions d'abonnement aux messages. L'exemple de code est le suivant :

require 'vendor/autoload.php';

use RatchetMessageComponentInterface;
use RatchetConnectionInterface;
use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;
use PredisClient;

class Chat implements MessageComponentInterface
{
    protected $clients;
    protected $redis;
    
    public function __construct()
    {
        $this->clients = new SplObjectStorage();
        $this->redis = new Client();
    }
    
    public function onOpen(ConnectionInterface $conn)
    {
        $this->clients->attach($conn);
        echo "New client connected: " . $conn->resourceId . PHP_EOL;
    }
    
    public function onMessage(ConnectionInterface $from, $msg)
    {
        $this->redis->publish('chat', $msg);
    }
    
    public function onClose(ConnectionInterface $conn)
    {
        $this->clients->detach($conn);
        echo "Client disconnected: " . $conn->resourceId . PHP_EOL;
    }
    
    public function onError(ConnectionInterface $conn, Exception $e)
    {
        echo "An error has occurred: " . $e->getMessage() . PHP_EOL;
        $conn->close();
    }
}

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

$server->run();

Le code ci-dessus est similaire au code de notification de diffusion. La seule différence est que dans la méthode onMessage, nous utilisons la méthode de publication de la bibliothèque Predis pour pousser le message reçu vers le 'chat. ' chaîne de Redis. De cette façon, nous implémentons la fonction d'abonnement aux messages.

Ensuite, nous avons besoin d'un client pour recevoir des messages push. Une simple page client peut être écrite en utilisant JavaScript. L'exemple de code est le suivant :

<!DOCTYPE html>
<html>
<head>
    <title>Chat Client</title>
    <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
    <script>
        var ws = new WebSocket("ws://localhost:8080");

        ws.onmessage = function(event) {
            var message = event.data;
            $("#messages").append("<p>" + message + "</p>");
        };
    </script>
</head>
<body>
    <div id="messages"></div>
</body>
</html>

Le code ci-dessus crée un objet WebSocket, se connecte à notre serveur WebSocket et affiche le message sur la page lorsque le message est reçu.

En exécutant le code ci-dessus, nous avons implémenté un système de chat simple en temps réel avec des fonctions de notification de diffusion et d'abonnement aux messages. Le serveur peut envoyer des messages à tous les clients connectés en temps réel et les clients peuvent recevoir les messages en temps réel.

Pour résumer, cet article présente comment utiliser PHP pour développer les fonctions de notification de diffusion et d'abonnement aux messages du système de chat en temps réel. En utilisant la bibliothèque Ratchet pour implémenter le serveur WebSocket, nous pouvons facilement gérer les fonctions de notification de diffusion et d'abonnement aux messages. Dans le même temps, en utilisant Redis comme file d'attente de messages, nous pouvons enregistrer et envoyer des messages. Cette méthode peut être largement utilisée dans les réseaux sociaux, la messagerie instantanée et d’autres systèmes pour offrir aux utilisateurs une meilleure expérience de communication en temps réel.

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!