So verwenden Sie die WebSockets-API für die Echtzeitkommunikation in PHP

WebSockets API ist ein neues Protokoll für die Echtzeitinteraktion auf Webseiten. Sein größter Vorteil besteht darin, dass es eine bidirektionale Kommunikation erreichen kann, die eine Echtzeitkommunikation zwischen dem Server und dem Client ermöglicht. In PHP können wir die Ratchet-Bibliothek verwenden, um die Funktionalität von WebSockets zu implementieren. In diesem Artikel wird detailliert beschrieben, wie Sie die WebSockets-API in PHP verwenden, um eine Echtzeitkommunikation zu erreichen.

1. Installieren Sie die Ratchet-Bibliothek

Bevor wir mit der Implementierung der WebSockets-Funktion beginnen, müssen wir die Ratchet-Bibliothek installieren. Die Ratchet-Bibliothek ist ein in PHP implementierter WebSockets-Server, der uns dabei helfen kann, WebSockets-Funktionen schnell zu implementieren. Es ist sehr praktisch, die Ratchet-Bibliothek über Composer zu installieren. Wir müssen nur den folgenden Befehl im Projektverzeichnis ausführen:

composer require cboden/ratchet

2. Erstellen Sie einen WebSockets-Server

Nach der Installation der Ratchet-Bibliothek können wir einen WebSockets-Server erstellen. Implementieren Sie in PHP einen WebSockets-Server, indem Sie eine Klasse erstellen, die von RatchetServerIoServer erbt. Wir müssen zuerst die Ratchet-Bibliothek einführen, dann eine Klasse namens WebSocketServer erstellen und eine WebSocket-Serverinstanz generieren.

use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;

class WebSocketServer {
    public function __construct() {
        $server = IoServer::factory(
            new HttpServer(
                new WsServer(
                    new Chat()
                )
            ),
            8080
        );
        $server->run();
    }
}

Im obigen Code haben wir eine WebSocket-Serverinstanz erstellt und diese auf Port 8080 ausgeführt. Bevor der WebSockets-Server ausgeführt wird, müssen wir eine Klasse namens Chat erstellen, um die Geschäftslogik des Servers zu implementieren. Die Chat-Klasse wird verwendet, um Vorgänge wie Client-Verbindung, Verbindungstrennung und Empfangen von Nachrichten abzuwickeln.

3. Behandeln Sie Client-Verbindungen und -Trennungen.

Als nächstes müssen wir Client-Verbindungen, -Trennungen und Nachrichtenempfangsvorgänge in der Chat-Klasse implementieren. Wenn der Client eine Verbindung herstellt, müssen wir ihn protokollieren und ihm eine Willkommensnachricht senden. Wenn der Client die Verbindung trennt, müssen wir ihn aus dem Datensatz entfernen. Das Folgende ist der Code, der Client-Verbindungen und -Trennungen verarbeitet:

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);
        echo "New client connected: {$conn->resourceId}
";
        $conn->send("Welcome!
");
    }

    public function onClose(ConnectionInterface $conn) {
        $this->clients->detach($conn);
        echo "Client disconnected: {$conn->resourceId}
";
    }
}

Im obigen Code erstellen wir im Konstruktor der Chat-Klasse ein SplObjectStorage-Objekt mit dem Namen „clients“, um alle Client-Verbindungen zu speichern. Wenn in der onOpen-Methode ein Client eine Verbindung herstellt, speichern wir diese in Clients und senden eine Willkommensnachricht an den Client. Wenn ein Client in der onClose-Methode die Verbindung trennt, entfernen wir ihn von den Clients.

4. Verarbeiten des Sendens und Sendens von Nachrichten

Nachdem die logische Verarbeitung der Clientverbindung und -trennung abgeschlossen ist, müssen wir die Logik zum Empfangen von Nachrichten, Senden von Nachrichten und Senden von Nachrichten implementieren. In der Chat-Klasse müssen wir die Methode onMessage implementieren, um die empfangenen Nachrichten zu verarbeiten und verschiedene Nachrichten an den Absender und andere Clients zu senden.

public function onMessage(ConnectionInterface $from, $msg) {
    $data = json_decode($msg);
    $numRecv = count($this->clients) - 1;
    if ($data->type === 'message') {
        foreach ($this->clients as $client) {
            if ($client !== $from) {
                // The sender is not the receiver, send to each client connected
                $client->send(json_encode([
                    'type' => 'message',
                    'user' => $data->user,
                    'message' => $data->message
                ]));
            } else {
                $from->send(json_encode([
                    'type' => 'message',
                    'user' => 'You',
                    'message' => $data->message
                ]));
            }
        }
    }
}

Im obigen Code analysieren wir zunächst die empfangene Nachricht und führen je nach Nachrichtentyp unterschiedliche Verarbeitungen durch. Wenn der Nachrichtentyp „Nachricht“ ist, müssen wir eine Nachricht an alle Clients senden. Wenn der Absender nicht der Empfänger ist, senden Sie jeweils unterschiedliche Nachrichten an den Empfänger und den Absender.

Abschließend müssen wir die Chat-Klasse in der WebSocketServer-Klasse instanziieren und den WebSockets-Server starten:

new WebSocketServer();

Durch die oben genannten Schritte haben wir die Ratchet-Bibliothek erfolgreich verwendet, um die Echtzeitkommunikation mit der WebSockets-Funktion zu implementieren Stellen Sie über JavaScript eine Verbindung zu WebSockets her. Der Server sendet und empfängt Nachrichten, wobei JavaScript auf der Clientseite mit Hilfe der WebSockets-API implementiert werden kann. Dies wird hier nicht näher erläutert.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die WebSockets-API für die Echtzeitkommunikation in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!