Comment gérer les interrogations longues et WebSocket dans le développement d'API PHP

Avec le développement d'Internet et de l'Internet mobile, de plus en plus d'applications doivent mettre en œuvre des fonctions de communication en temps réel. Dans le développement Web, Long Polling et WebSocket sont deux protocoles couramment utilisés qui peuvent implémenter des fonctions de communication en temps réel. Dans le développement d'API PHP, la manière de gérer les interrogations longues et WebSocket est un problème qui doit être pris en compte.

1. Long Polling

Long Polling (long polling) est une technologie qui permet une communication en temps réel. Son principe de base est que le client envoie une requête au serveur et que le serveur ne répond pas immédiatement à la requête, mais maintient la connexion ouverte et attend de nouvelles données avant de les renvoyer au client. après avoir reçu les données.

Dans le développement de l'API PHP, la méthode de gestion du Long Polling est similaire à la gestion des requêtes ordinaires, sauf que vous devez garder la connexion ouverte et attendre que les données soient renvoyées. Voici un exemple de code :

<?php
// 开启一个长轮询连接
while(true) {
    // 查询是否有新的数据
    $new_data = get_new_data();
    if(!empty($new_data)) {
        // 返回查询到的新数据
        echo json_encode($new_data);
        // 关闭连接，等待下一次请求
  exit;
    }
    // 等待一段时间再次查询
    sleep(1);
}
?>

Dans le code ci-dessus, nous utilisons une boucle while pour maintenir la connexion ouverte, attendons que de nouvelles données soient renvoyées au client et attendons un moment pour demander à nouveau s'il y a de nouvelles données. Cette méthode ne convient pas aux scénarios à forte concurrence car chaque connexion occupera un processus. Si de nombreux clients effectuent de longues interrogations en même temps, le serveur sera rapidement épuisé.

Afin de résoudre ce problème, nous pouvons utiliser des écouteurs d'événements ou des files d'attente de messages pour gérer les demandes d'interrogation longue. Lorsqu'il y a de nouvelles données, déclenchez un écouteur d'événement ou envoyez-le à la file d'attente des messages, puis utilisez une longue connexion d'interrogation pour obtenir les données. Cela peut réduire la charge sur le serveur et améliorer la stabilité du système. Voici un exemple de code permettant d'utiliser Redis pour gérer les requêtes Long Polling :

<?php
$redis = new Redis();
$redis->connect('127.0.0.1',6379);

// 开启一个长轮询连接
while(true) {
    $new_data = $redis->subscribe(['new_data']);
    if(!empty($new_data)) {
        // 返回新数据
        echo json_encode($new_data);
        // 关闭连接，等待下一次请求
  exit;
    }
}
?>

Dans le code ci-dessus, nous utilisons la méthode d'abonnement de Redis pour surveiller la transmission de nouvelles données. Lorsqu'il y a de nouvelles données, renvoyez-les au client et. quitter la connexion. Cette méthode n'occupe pas les ressources du serveur et convient aux scénarios de communication en temps réel à forte concurrence.

2. WebSocket

WebSocket est une autre technologie qui permet une communication en temps réel. Elle peut établir une connexion persistante bidirectionnelle entre le client et le serveur pour établir une communication en temps réel. Sur WebSocket, les messages peuvent être envoyés entre clients et serveurs sans qu'il soit nécessaire d'établir et de fermer des connexions à plusieurs reprises, améliorant ainsi considérablement l'efficacité de la communication.

Dans le développement d'API PHP, des bibliothèques tierces peuvent être utilisées pour gérer WebSocket, telles que Ratchet, Swoole, etc. Le protocole WebSocket peut être facilement implémenté à l'aide de ces bibliothèques et peut également prendre en charge une variété de protocoles et d'événements personnalisés, ce qui rend le développement très pratique. Voici un exemple de code pour utiliser Ratchet pour gérer WebSocket :

<?php
require __DIR__ . '/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);
    }

    public function onMessage(ConnectionInterface $conn, $msg) {
        // 收到客户端消息
        foreach ($this->clients as $client) {
            if ($conn === $client) {
                continue;
            }
            $client->send($msg); // 发送消息给其他客户端
        }
    }

    public function onClose(ConnectionInterface $conn) {
        // 客户端断开连接
        $this->clients->detach($conn);
    }

    public function onError(ConnectionInterface $conn, Exception $e) {
      // 出错时的处理
    }
}

// 启动聊天服务
$server = IoServer::factory(
    new HttpServer(
        new WsServer(
            new Chat()
        )
    ),
    8080
);
$server->run();
?>

Dans le code ci-dessus, nous utilisons Ratchet pour implémenter un service de discussion simple Lorsqu'un client se connecte, la méthode onOpen sera déclenchée lorsqu'un client envoie un message ; la méthode onMessage sera déclenchée ; lorsqu'un client se déconnecte, la méthode onClose sera déclenchée ; lorsqu'une erreur se produit, la méthode onError sera déclenchée. Dans ce service, nous diffusons simplement les messages envoyés par le client à d'autres clients, en mettant en œuvre un simple salon de discussion.

Résumé

Dans le développement d'API PHP, différentes technologies et méthodes peuvent être utilisées pour gérer les interrogations longues et WebSocket. La méthode Long Polling est relativement simple. Vous pouvez utiliser une boucle while pour attendre l'arrivée de nouvelles données, mais elle occupera des ressources du serveur. La méthode WebSocket est relativement complexe et peut être implémentée à l'aide de bibliothèques tierces. Elle peut également prendre en charge une variété de protocoles et d'événements personnalisés, ce qui la rend très pratique à développer. Quelle que soit la méthode utilisée, les problèmes d'occupation des ressources et de performances du serveur doivent être pris en compte pour garantir la stabilité et la fiabilité du système.

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!