Analyse comparative de la fonction de communication en temps réel PHP et de la technologie Push du serveur

Analyse comparative de la fonction de communication en temps réel PHP et de la technologie push du serveur

Avec le développement rapide d'Internet, la fonction de communication en temps réel devient de plus en plus importante dans les sites Web et les applications. Le modèle traditionnel de requête-réponse HTTP ne peut pas répondre aux besoins des utilisateurs en matière d'informations en temps réel, c'est pourquoi une série de solutions de communication en temps réel ont vu le jour. Cet article comparera les capacités de communication en temps réel et la technologie push du serveur dans le langage PHP et démontrera leur application à travers des exemples de code.

1. Fonction de communication en temps réel en PHP

PHP, en tant que langage de script côté serveur, communique principalement avec le client via le protocole HTTP. Les applications PHP traditionnelles utilisent un mécanisme d'interrogation pour obtenir des mises à jour instantanées, mais cette méthode est inefficace et consomme une grande quantité de ressources du serveur. À mesure que la technologie progresse, les développeurs PHP commencent à explorer des solutions de communication en temps réel plus efficaces.

1.1 WebSockets

WebSockets est un protocole de communication full-duplex qui permet une communication en temps réel entre les serveurs et les clients. Il utilise le protocole HTTP standard pour établir une liaison, puis établir une connexion persistante. PHP peut facilement implémenter les fonctions WebSockets via des frameworks tels que Ratchet et Swoole. Voici un exemple de code PHP simple :

require 'vendor/autoload.php';

use RatchetMessageComponentInterface;
use RatchetConnectionInterface;

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 $from, $msg) {
        foreach ($this->clients as $client) {
            if ($from !== $client) {
                $client->send($msg);
            }
        }
    }

    public function onClose(ConnectionInterface $conn) {
        $this->clients->detach($conn);
    }

    public function onError(ConnectionInterface $conn, Exception $e) {
        $conn->close();
    }
}

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

$server->run();

Le code ci-dessus crée un simple serveur de discussion qui peut envoyer des messages à tous les clients connectés en temps réel.

1.2 Événement envoyé par le serveur (SSE)

L'événement envoyé par le serveur est un protocole permettant au serveur d'envoyer des événements au client. Il établit une connexion persistante et envoie des données au format texte. Comparé aux WebSockets, SSE est plus adapté à la communication unidirectionnelle et présente des exigences en temps réel moindres. Ce qui suit est un exemple de code PHP simple :

header('Content-Type: text/event-stream');
header('Cache-Control: no-cache');
header('Connection: keep-alive');

$lastEventId = isset($_SERVER["HTTP_LAST_EVENT_ID"]) ? $_SERVER["HTTP_LAST_EVENT_ID"] : null;
$counter = $lastEventId ? intval($lastEventId) : 0;

while (true) {
    $counter++;
    echo "id: $counter
";
    echo "data: This is event $counter

";
    flush();
    usleep(1000000); // 1秒延迟
}

Le code ci-dessus crée un simple envoi d'événement côté serveur, envoyant un événement au client chaque seconde.

2. Server Push Technology

En plus d'implémenter des fonctions de communication en temps réel dans le langage PHP, certaines technologies Server Push sont également utilisées pour fournir des solutions de communication en temps réel plus efficaces.

2.1 Serveur WebSocket

Semblable aux WebSockets ci-dessus, le serveur WebSocket est un serveur capable d'établir une communication en duplex intégral. Par rapport à l'utilisation de PHP pour implémenter WebSockets, il est plus efficace d'utiliser un serveur WebSocket dédié. Voici un exemple de code Node.js simple :

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
  ws.on('message', function incoming(message) {
    wss.clients.forEach(function each(client) {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(message);
      }
    });
  });
});

Le code ci-dessus crée un simple serveur WebSocket Lorsqu'un client envoie un message, le serveur enverra le message à tous les clients connectés.

2.2 Longue interrogation

L'interrogation longue est une technologie push du serveur qui obtient un effet similaire à la communication en temps réel en définissant un long délai d'attente dans la requête. Ce qui suit est un exemple de code PHP simple :

while (true) {
    $newData = getData();

    if ($newData !== null) {
        echo json_encode($newData);
        break;
    }

    usleep(1000000); // 延迟1秒
}

Le code ci-dessus boucle pour vérifier si de nouvelles données sont disponibles pour le client et, si c'est le cas, encode les données au format JSON et les affiche.

En résumé, la fonction de communication en temps réel et la technologie server push dans le langage PHP ont joué un rôle important dans la réalisation d'une communication en temps réel. Grâce à WebSockets et SSE, PHP peut directement fournir des capacités de communication en temps réel. Avec l'aide du serveur WebSocket et de la technologie d'interrogation longue, la communication en temps réel peut être réalisée plus efficacement. Lors du choix, vous devez peser les exigences spécifiques et la complexité de la mise en œuvre technique.

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!