Interface API PHP : Comment utiliser les WebSockets

PHP est un langage de script open source côté serveur couramment utilisé pour créer des sites Web et des applications Web dynamiques. Les interfaces API PHP sont généralement fournies via le protocole HTTP, mais avec les exigences croissantes des applications Web modernes, la mise à jour des données en temps réel est devenue plus importante. Cela nécessite l'utilisation de WebSockets pour une communication bidirectionnelle afin de répondre plus rapidement aux changements.

WebSockets est un nouveau type de canal de communication entre client et serveur en HTML5. Il permet une transmission de données bidirectionnelle en temps réel en maintenant une connexion pendant une longue période. Contrairement aux requêtes HTTP, les WebSockets ouvrent un socket TCP sur la connexion WebSocket au lieu d'en créer un à chaque requête. Cela signifie que les WebSockets permettent un transfert de données en temps réel plus rapide et plus simple que les requêtes HTTP.

Cet article expliquera comment utiliser l'interface API PHP pour communiquer avec WebSockets afin de mettre à jour les données dans les applications Web en temps réel.

1. Installer Ratchet
Pour utiliser WebSockets, vous devez installer Ratchet, une bibliothèque WebSocket très populaire en PHP. Vous pouvez télécharger Ratchet depuis Github et l'ajouter à votre projet, ou l'installer à l'aide de Composer.

Si vous utilisez Composer, vous pouvez exécuter la commande suivante :

composer require cboden/ratchet

Cela installera automatiquement Ratchet. Une fois installé, vous pourrez créer un serveur WebSocket en utilisant sa classe WebSocket Server.

2. Créer un serveur WebSocket
À l'aide de Ratchet, vous pouvez créer un serveur WebSocket pour une communication en temps réel avec les clients. Voici un exemple de code de base du serveur WebSocket :

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

require_once(__DIR__ . '/vendor/autoload.php');

class MyWebSocket implements MessageComponentInterface
{
    public function onOpen(ConnectionInterface $conn)
    {
        // 当有新客户端连接时执行
        echo "New connection! ({$conn->resourceId})
";
    }

    public function onMessage(ConnectionInterface $from, $msg)
    {
        // 接收消息
        echo "Received message: {$msg}
";

        // 回复消息
        $from->send('Data received: ' . $msg);
    }

    public function onClose(ConnectionInterface $conn)
    {
        // 当客户端断开连接时执行
        echo "Connection {$conn->resourceId} has disconnected
";
    }

    public function onError(ConnectionInterface $conn, Exception $e)
    {
        // 当出现错误时执行
        echo "An error has occurred: {$e->getMessage()}
";

        $conn->close();
    }
}

// 创建WebSocket服务器
$server = IoServer::factory(
    new WsServer(
        new MyWebSocket()
    ),
    8080
);

// 启动WebSocket服务器
$server->run();

Le code ci-dessus crée un serveur WebSocket qui peut accepter les connexions client à partir du port 8080. Il n'a pas de véritable logique métier, il imprime simplement les événements de connexion, de message et de déconnexion. Vous pouvez l'utiliser comme point de départ et personnaliser votre propre classe de serveur WebSocket selon vos besoins.

3. Le client utilise l'API WebSocket
Côté client, vous pouvez utiliser l'API WebSocket pour établir une connexion avec le serveur et envoyer et recevoir des messages. Voici l'exemple de client WebSocket le plus simple :

var connection = new WebSocket('ws://localhost:8080');

connection.onopen = function () {
    console.log('WebSocket connected');

    // 发送消息
    connection.send('Hello, WebSocket server!');
};

connection.onmessage = function (event) {
    console.log('Received message: ' + event.data);
};

connection.onclose = function (event) {
    console.log('WebSocket connection closed with code ' + event.code + ' and reason: ' + event.reason);
};

connection.onerror = function (error) {
    console.log('WebSocket error: ' + error.message);
};

Ce code tentera de se connecter au serveur WebSocket que nous venons d'écrire. Lorsqu'un événement de connexion est reçu, il envoie un message. Lorsqu'un message est reçu du serveur, il l'enregistre sur la console. Gère également les situations de fermeture de connexion et d’erreur.

4. Utilisation de WebSockets via l'interface API PHP
Voyons maintenant comment communiquer avec WebSockets à l'aide de l'interface API PHP. Vous pouvez utiliser un routeur API traditionnel pour gérer les requêtes WebSocket. Lorsqu'un client se connecte à un serveur WebSocket, vous pouvez utiliser l'interface ConnectionInterface de Ratchet WebSocket pour récupérer les informations pertinentes. Vous pouvez également utiliser ces informations pour authentifier les connexions et garantir que seuls les utilisateurs authentifiés peuvent se connecter au serveur WebSocket.

Voici l'exemple de code :

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

require_once(__DIR__ . '/vendor/autoload.php');

// 自定义WebSocket服务器类
class MyWebSocket implements MessageComponentInterface
{
    protected $clients;

    public function __construct()
    {
        $this->clients = new SplObjectStorage;
    }

    public function onOpen(ConnectionInterface $conn)
    {
        // 将新连接存储到$clients
        $this->clients->attach($conn);

        // 获取客户端地址
        $client_ip = $conn->remoteAddress;

        // 处理新连接（验证身份、发送欢迎消息等）
        // ...
    }

    public function onMessage(ConnectionInterface $from, $msg)
    {
        // 处理收到的消息
        // ...
    }

    public function onClose(ConnectionInterface $conn)
    {
        // 从$clients中删除关闭连接
        $this->clients->detach($conn);

        // 处理关闭连接
        // ...
    }

    public function onError(ConnectionInterface $conn, Exception $e)
    {
        // 处理WebSocket错误
        // ...

        // 关闭连接
        $conn->close();
    }
}

// 创建WebSocket服务器
$server = IoServer::factory(
    new WsServer(
        new MyWebSocket()
    ),
    8080
);

// 启动WebSocket服务器
$server->run();

Dans la méthode onOpen, nous pouvons effectuer certains traitements, comme vérifier la connexion, envoyer un message de bienvenue au client et enregistrer la nouvelle connexion. Dans la méthode onClose, nous pouvons gérer l'événement de fermeture de la connexion, comme la suppression de la connexion de la liste et l'envoi d'une notification hors ligne à d'autres clients.

Dans la méthode onMessage, nous pouvons gérer le message envoyé par le client WebSocket. Étant donné que WebSocket est un canal de communication bidirectionnel, cela signifie que le client peut également envoyer des messages au serveur, plutôt que simplement le serveur envoyant des messages au client, ce qui améliore considérablement la capacité de l'application à envoyer et recevoir des données.

En communiquant avec WebSockets via l'interface API PHP, vous pouvez mettre à jour les données en temps réel, ce qui est d'une grande importance pour les applications en temps réel telles que les transactions en temps réel, l'envoi de messages et les applications de jeux.

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!