Intégration de Swoole et Redis : créez rapidement un système de messagerie instantanée à haute disponibilité

Avec l'essor de l'Internet mobile, le système de messagerie instantanée (MI) est devenu un élément indispensable de notre vie quotidienne. Par conséquent, développer un système de messagerie instantanée pratique et performant est devenu l'un des objectifs poursuivis par de nombreux développeurs. Dans ce processus, Swoole et Redis sont deux outils de performance couramment utilisés qui peuvent nous aider à créer rapidement un système de messagerie instantanée à haute disponibilité.

Cet article présentera les concepts et principes de base de Swoole et Redis, et présentera un cas d'architecture de système de messagerie instantanée et un plan de mise en œuvre basé sur ces deux outils. J'espère qu'à travers cet article, les lecteurs pourront comprendre comment utiliser ces deux outils pour créer un système de messagerie instantanée hautes performances.

1. Présentation de Swoole et Redis

1.1 Swoole

Swoole est un framework réseau avancé basé sur PHP. Il s'agit d'un moteur côté serveur entièrement asynchrone et hautes performances qui prend en charge les protocoles TCP, UDP, WebSocket et HTTP. Swoole peut grandement améliorer les performances et la concurrence des processus PHP, principalement grâce à son mécanisme de réaction basé sur epoll ou kqueue, qui utilise la technologie coroutine pour implémenter une programmation asynchrone non bloquante.

1.2 Redis

Redis est une base de données clé-valeur open source en mémoire qui prend en charge une variété de structures de données, notamment des chaînes, des hachages, des listes, des ensembles et des ensembles ordonnés. Redis offre des performances et une évolutivité élevées et peut gérer des millions de requêtes simultanées. Redis est principalement utilisé dans des scénarios tels que la mise en cache, les files d'attente de messages et les verrous distribués.

2. Intégration de Swoole et Redis

2.1 Comment Swoole fonctionne avec Redis

Il existe généralement deux façons d'utiliser Redis dans Swoole :

• Utiliser le client Swoole Redis
• Utiliser le client Swoole Coroutine Redis

Parmi elles, le client Swoole Redis est un client Redis traditionnel et doit utiliser des fonctions de rappel pour traiter les réponses aux demandes ; tandis que le client Coroutine Redis traite les demandes et les réponses via des coroutines, ce qui est plus pratique et efficace à utiliser.

2.2 Description de l'architecture

Afin d'établir une communication en temps réel, les systèmes de messagerie instantanée utilisent généralement le protocole WebSocket pour transmettre des messages. Dans cet article, nous allons construire un serveur WebSocket basé sur Swoole et Redis. Les messages envoyés par le client seront enregistrés dans Redis puis transmis aux autres clients via le serveur.

• 1. Le client envoie un message au serveur WebSocket
• 2. Le serveur WebSocket enregistre le message sur Redis
• 3. Redis envoie le message au serveur
• 4. Le serveur WebSocket pousse messages à d'autres clients

3. Plan de mise en œuvre

Ensuite, nous présenterons le plan de mise en œuvre en détail pour chaque étape.

3.1 Code du serveur

(1) Démarrez le serveur WebSocket

Utilisez l'API du serveur WebSocket fournie par Swoole pour démarrer le serveur. Le code est le suivant :

$server = new SwooleWebSocketServer("0.0.0.0", 9501);

$server->on('open', function (SwooleWebSocketServer $server, $frame) {
    echo "connection open
";
});

$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    $redis = new SwooleCoroutineRedis();
    $redis->connect('127.0.0.1', 6379);
    $redis->lPush('messages', $frame->data);
});

$server->on('close', function (SwooleWebSocketServer $server, $fd) {
    echo "connection close
";
});

$server->start();

Dans ce code, nous utilisons le $server-> Fonction on() pour définir les fonctions de rappel d'événement d'ouverture, de message et de fermeture de WebSocket. Lorsque le client se connecte au serveur, le code de la fonction open sera exécuté ; lorsque le client envoie un message au serveur, le code de la fonction de message sera exécuté. Dans la fonction de message, nous créons un client Coroutine Redis et mettons en cache les messages envoyés par le client dans la file d'attente Redis.

(2) Envoyer des messages au client

Ensuite, nous devons implémenter la logique du serveur qui envoie des messages au client. Ceci peut être réalisé en utilisant la fonction push() fournie par Swoole. Le code est le suivant :

// 推送消息给客户端
$server->tick(1000, function () use ($server) {
    $redis = new SwooleCoroutineRedis();
    $redis->connect('127.0.0.1', 6379);

    while ($message = $redis->rPop('messages')) {
        foreach ($server->connections as $fd) {
            $server->push($fd, $message);
        }
    }
});

Dans ce code, nous utilisons la fonction tick() fournie par Swoole pour exécuter le code régulièrement, utilisons le client Coroutine Redis pour récupérer le message de Redis et les messages Push à tous les clients.

3.2 Code client

Le code client est relativement simple. Il nous suffit d'utiliser le client WebSocket pour nous connecter au serveur WebSocket et envoyer et recevoir des données via JavaScript. Le code est le suivant :

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>IM System</title>
</head>
<body>
    <h1>IM System</h1>
    <form>
        <label for="name">Name:</label>
        <input type="text" id="name">
        <br><br>
        <label for="message">Message:</label>
        <input type="text" id="message">
        <br><br>
        <input type="submit" value="Send Message">
    </form>
    <br><br>
    <div id="message-list"></div>
    <script>
        var socket = new WebSocket('ws://localhost:9501');

        socket.onopen = function(event) {
            console.log('WebSocket connect succeed');
        };

        socket.onmessage = function(event) {
            var message = JSON.parse(event.data);

            var messageList = document.getElementById('message-list');
            var p = document.createElement('p');
            p.innerText = message.name + ": " + message.message;
            messageList.prepend(p);
        };

        document.querySelector('form').addEventListener('submit', function(event) {
            event.preventDefault();

            var name = document.getElementById('name').value;
            var message = document.getElementById('message').value;

            socket.send(JSON.stringify({
                name: name,
                message: message
            }));

            document.getElementById('message').value = "";
        });
    </script>
</body>
</html>

Dans ce code, nous utilisons d'abord le client WebSocket pour nous connecter au serveur WebSocket. Lorsque le client se connecte avec succès, nous pouvons envoyer des messages au serveur via la méthode send() de l'objet WebSocket en JavaScript. Nous devons également définir la fonction de rappel onmessage pour recevoir les messages envoyés par le serveur.

4. Résumé

Dans cet article, nous avons présenté les concepts et principes de base de Swoole et Redis, et partagé un cas d'architecture de serveur WebSocket et un plan de mise en œuvre basé sur Swoole et Redis. Grâce à ce cas, nous pouvons découvrir comment Swoole et Redis travaillent ensemble pour créer un système de messagerie instantanée hautes performances et haute disponibilité.

Bien sûr, ce n'est qu'un exemple simple. En pratique, de nombreux aspects doivent être pris en compte, comme la sécurité, l'optimisation des performances, etc. J'espère que les lecteurs pourront en apprendre davantage sur l'utilisation de ces deux outils à travers cet article. J'espère également que les lecteurs pourront continuer à étudier en profondeur ces deux outils et d'autres technologies associées et apporter davantage de contributions au développement d'applications hautes performances.

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!