Expérience de développement de serveur WebSocket haute performance basée sur Swoole

Websocket est un protocole de communication full-duplex basé sur TCP, qui permet au client et au serveur d'interagir avec les données en temps réel. Le protocole Websocket convient aux scénarios d'application tels que la transmission de données en temps réel et les jeux en ligne. Contrairement au protocole HTTP, le Websocket peut maintenir une connexion longue, évitant ainsi l'inconvénient du protocole HTTP qui nécessite l'établissement d'une connexion TCP pour chaque requête. . Par conséquent, de plus en plus de produits utilisent le protocole Websocket pour la transmission de données.

Afin d'améliorer les performances du serveur Websocket, nous pouvons utiliser l'extension Swoole pour le développement. Swoole est un framework de communication réseau PHP hautes performances couramment utilisé. Il est basé sur le modèle asynchrone basé sur les événements et implémente des coroutines couramment utilisées dans les frameworks hautes performances tels que React et Node.js, ce qui améliore considérablement les performances de PHP. Dans cet article, nous présenterons comment développer un serveur Websocket hautes performances sous Swoole et partagerons quelques expériences connexes.

1. Démarrez le service Swoole

Avant de démarrer le service Swoole, nous devons d'abord installer l'extension Swoole. Swoole prend en charge les systèmes d'exploitation courants tels que Windows, Linux, macOS, etc. Nous pouvons utiliser la commande pecl pour installer des extensions, ou télécharger le code source depuis le site officiel de Swoole pour la compilation et l'installation. Ici, nous prenons l'installation de la commande pecl comme exemple :

pecl install swoole

Une fois l'installation terminée, vous pouvez utiliser la fonction swoole_version() dans le code PHP pour afficher les informations de version de Swoole afin de vous assurer que l'extension a été installé correctement. swoole_version()函数查看Swoole版本信息，以确保扩展已经被正确安装。

1. 创建服务实例

在使用Swoole开发Websocket服务器前，首先需要创建一个服务实例，我们可以使用Swoole提供的SwooleWebSocketServer类来创建，如下：

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

其中，0.0.0.0表示监听所有可用的IP地址，9501表示监听的端口号。在创建实例后，我们可以对服务器进行一些配置，例如设置worker进程数、设置运行模式、启用TCP协议等，具体请参考Swoole官方文档。

2. 注册事件回调函数

Websocket服务器与客户端的通信是通过事件回调函数来实现的，我们需要在服务实例中注册回调函数，以便服务实例能够响应相应的事件。Swoole提供了很多回调函数（例如onMessage、onOpen、onClose、onRequest、onHandShake等），我们在开发Websocket服务器时，通常需要注册如下三个回调函数：

//连接成功时触发
$server->on('open', function (SwooleWebSocketServer $server, $request) {
    //处理连接事件
});

//收到客户端消息时触发
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    //处理消息事件
});

//连接关闭时触发
$server->on('close', function (SwooleWebSocketServer $server, $fd) {
    //处理关闭事件
});

其中，open事件在客户端成功建立连接后，message事件在客户端发送消息后，close事件在连接关闭后触发。在Swoole中，$frame对象表示WebSocket消息的数据体，可以通过$frame->data获取消息的具体内容。

3. 启动服务

注册完回调函数后，我们就可以启动服务，代码如下：

$server->start();

在启动服务时，会自动创建worker进程和reactor线程，用于处理客户端连接和消息发送等业务流程。

二、Websocket服务开发经验

在使用Swoole开发Websocket服务器时，还需要注意以下几个方面：

1. 心跳机制

Websocket协议不像HTTP协议中有明确的请求和响应，而是采用消息推送的方式进行实时数据传输。由于Websocket服务器需要长时间监听客户端的连接和消息传输，一旦客户端断开连接就无法发送消息，因此需要我们实现心跳机制，定时向客户端发送心跳请求，以维持连接。在Swoole中，我们可以使用ping和pong消息来实现心跳机制。

//心跳包
$server->tick(30000, function () use ($server) {
    foreach ($server->connections as $fd) {
        $server->push($fd, json_encode(['type' => 'ping']));
    }
});

//心跳响应
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    if ($frame->data == 'pong') {
        //处理心跳响应
    }
});

其中，tick函数可以定时向客户端发送心跳请求，onMessage回调函数中可以处理客户端的心跳响应，以确保客户端与服务端保持连接。

2. 消息广播

Websocket服务器很常见的场景是向所有客户端广播消息，例如弹幕、多人游戏等。在Swoole中，我们可以使用push方法广播消息。

//处理广播消息
$message = 'Hello, everyone!';
foreach ($server->connections as $fd) {
    $server->push($fd, $message);
}

此外，还可以根据客户端的连接信息，针对性向特定客户端发送消息。

3. 数据格式化

Websocket协议中，客户端和服务端通信的数据可能以JSON、XML等格式传输，因此在处理接收到的数据时，我们需要对数据进行格式化处理，例如使用json_decode

Créer une instance de service
Avant d'utiliser Swoole pour développer un serveur Websocket, vous devez d'abord créer une instance de service. Nous pouvons utiliser la classe SwooleWebSocketServer fournie par Swoole pour la créer, comme suit :

//处理消息事件
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    $data = json_decode($frame->data, true);
    //处理数据
});

where , 0.0.0.0 signifie écouter sur toutes les adresses IP disponibles, et 9501 signifie le numéro de port d'écoute. Après avoir créé l'instance, nous pouvons effectuer certaines configurations sur le serveur, telles que définir le nombre de processus de travail, définir le mode de fonctionnement, activer le protocole TCP, etc. Pour plus de détails, veuillez vous référer à la documentation officielle de Swoole.

Enregistrer la fonction de rappel d'événement

🎜🎜La communication entre le serveur Websocket et le client est réalisée via la fonction de rappel d'événement. Nous devons enregistrer la fonction de rappel dans l'instance de service afin que le service soit activé. l'instance peut répondre à l'événement correspondant. Swoole fournit de nombreuses fonctions de rappel (telles que onMessage, onOpen, onClose, onRequest, onHandShake, etc.). Lorsque nous développons un serveur Websocket, nous devons généralement enregistrer les trois fonctions de rappel suivantes : 🎜

$server->set([
    'worker_num' => 4,
]);

🎜 Parmi elles, l'événement open se produit. une fois que le client a établi avec succès une connexion, l'événement de message est déclenché après que le client a envoyé le message et l'événement close est déclenché après la fermeture de la connexion. Dans Swoole, l'objet $frame représente le corps de données du message WebSocket, et le contenu spécifique du message peut être obtenu via $frame->data. 🎜
🎜Démarrer le service🎜🎜🎜Après avoir enregistré la fonction de rappel, nous pouvons démarrer le service. Le code est le suivant : 🎜rrreee🎜Lors du démarrage du service, le processus de travail et le thread du réacteur seront. créé automatiquement pour le traitement des processus métier tels que la connexion client et l'envoi de messages. 🎜🎜2. Expérience de développement de services Websocket🎜🎜Lorsque vous utilisez Swoole pour développer un serveur Websocket, vous devez également faire attention aux aspects suivants : 🎜
🎜Mécanisme Heartbeat🎜🎜🎜Le protocole Websocket n'a pas de requêtes et de réponses claires. comme le protocole HTTP, le message push est utilisé pour la transmission de données en temps réel. Étant donné que le serveur Websocket doit surveiller la connexion du client et la transmission des messages pendant une longue période, il ne peut pas envoyer de messages une fois le client déconnecté. Par conséquent, nous devons implémenter un mécanisme de battement de cœur et envoyer régulièrement des requêtes de battement de cœur au client pour maintenir la connexion. Dans Swoole, nous pouvons utiliser les messages ping et pong pour implémenter le mécanisme de battement de cœur. 🎜rrreee🎜 Parmi eux, la fonction tick peut envoyer régulièrement des requêtes de battement de cœur au client, et la fonction de rappel onMessage peut traiter la réponse de battement de cœur du client pour garantir que le client maintient un connexion avec le serveur. 🎜
🎜Diffusion de messages🎜🎜🎜Un scénario très courant pour les serveurs Websocket consiste à diffuser des messages à tous les clients, tels que des barrages, des jeux multijoueurs, etc. Dans Swoole, on peut utiliser la méthode push pour diffuser des messages. 🎜rrreee🎜De plus, vous pouvez également envoyer des messages ciblés à des clients spécifiques en fonction des informations de connexion du client. 🎜
🎜Formatage des données🎜🎜🎜Dans le protocole Websocket, les données communiquées entre le client et le serveur peuvent être transmises en JSON, XML et d'autres formats, donc lors du traitement des données reçues, nous devons Effectuez le formatage, par exemple en utilisant json_decode pour analyser le format JSON. 🎜rrreee🎜🎜Gestion multi-processus🎜🎜🎜Dans le serveur Websocket, il y aura un grand nombre de requêtes clients Afin d'améliorer la capacité de traitement du serveur, nous pouvons utiliser la fonction de gestion multi-processus de Swoole. Swoole prend en charge le processus Master et plusieurs processus Worker. Le processus Master est utilisé pour gérer le processus Worker, et le processus Worker est responsable du traitement des demandes spécifiques des clients. Nous pouvons définir le nombre de processus Worker lors de la création d'une instance de service pour nous adapter aux charges de demandes de différentes tailles. 🎜rrreee🎜Dans un environnement multi-processus, vous devez faire attention aux problèmes de synchronisation et de partage des données. Vous pouvez utiliser Process, Table, Atomic, Mutex et d'autres composants fournis par Swoole pour réaliser la communication et la synchronisation inter-processus. 🎜

En bref, utiliser Swoole pour développer un serveur Websocket peut considérablement améliorer les performances et la stabilité du serveur. Cela nécessite également de maîtriser les fonctionnalités et les compétences de développement associées de Swoole. J'espère que cet article pourra être utile aux développeurs et fournir une référence pour une meilleure implémentation de serveurs Websocket 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!