Erstellen Sie Echtzeit-Webanwendungen mit WebSockets in PHP

Webanwendungen werden im modernen Internet immer beliebter und können eine umfassende Benutzererfahrung und Interaktion bieten. Allerdings weist das herkömmliche HTTP-Request-Response-Modell bestimmte Einschränkungen hinsichtlich der Echtzeitleistung und -effizienz auf. Um dieses Problem zu lösen, wurde WebSocket ins Leben gerufen. WebSocket ist ein Vollduplex-Kommunikationsprotokoll, das die Echtzeitkommunikation zwischen Clients und Servern ermöglicht. In diesem Artikel erfahren Sie, wie Sie Echtzeit-Webanwendungen mit PHP und WebSocket erstellen.

1. Was ist WebSocket?

WebSocket ist ein TCP-basiertes Vollduplex-Kommunikationsprotokoll, das eine bidirektionale Kommunikation über dieselbe TCP-Verbindung ermöglicht. Das herkömmliche HTTP-Protokoll ermöglicht nur eine einseitige Anfrage-Antwort-Kommunikation zwischen Client und Server. Mit dem WebSocket-Protokoll können Client und Server nach dem Verbindungsaufbau jederzeit Daten senden, ohne auf Anfragen warten zu müssen. Durch diesen Echtzeitcharakter und die Effizienz eignet sich das WebSocket-Protokoll für die Entwicklung von Echtzeit-Webanwendungen.

2. Warum WebSocket verwenden?

In Echtzeit-Webanwendungen müssen Benutzervorgänge und Datenaktualisierungen zeitnah an den Benutzer zurückgemeldet werden, um ein besseres Benutzererlebnis zu bieten. Das herkömmliche HTTP-Anfrage-Antwort-Modell weist eine gewisse Verzögerung auf und kann die Anforderungen der Echtzeitkommunikation nicht erfüllen. Darüber hinaus stellt das HTTP-Request-Response-Modell auch eine hohe Belastung für den Server dar. Jede Anfrage erfordert eine neue Verbindung, was den Kommunikationsaufwand erhöht. Daher kann die Verwendung von WebSocket die Echtzeitleistung verbessern und die Belastung des Servers verringern.

3. Erstellen Sie einen WebSocket-Server mit PHP

In PHP können Sie mit Hilfe der Ratchet-Bibliothek ganz einfach einen WebSocket-Server erstellen. Ratchet ist eine WebSocket-Bibliothek für PHP. Sie bietet die Implementierung des WebSocket-Protokolls und kann problemlos WebSocket-Server und -Clients erstellen, sodass wir bequem Echtzeit-Webanwendungen entwickeln können. Nachfolgend finden Sie die Schritte zum Erstellen eines WebSocket-Servers mit Ratchet.

Schritt 1: Installieren Sie die Ratchet-Bibliothek

Sie können das Composer-Tool verwenden, um die Ratchet-Bibliothek zu installieren. Führen Sie den folgenden Befehl im Terminal aus:

composer require cboden/ratchet

Schritt 2: Erstellen Sie eine Serverklasse

In der Serverklasse müssen wir zwei Methoden überschreiben: onOpen und onMessage. Die onOpen-Methode wird aufgerufen, wenn die Verbindung hergestellt wird, und die onMessage-Methode wird aufgerufen, wenn eine Nachricht empfangen wird. Hier ist ein einfaches Beispiel für eine Serverklasse:

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 connection! ({$conn->resourceId})
";
    }

    public function onMessage(ConnectionInterface $from, $msg) {
        foreach ($this->clients as $client) {
            if ($client !== $from) {
                $client->send($msg);
            }
        }
    }

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

    public function onError(ConnectionInterface $conn, Exception $e) {
        echo "An error has occurred: {$e->getMessage()}
";
        $conn->close();
    }
}

Im obigen Beispiel haben wir eine Klasse namens Chat definiert, die die MessageComponentInterface-Schnittstelle implementiert. Im Konstruktor initialisieren wir eine Verbindungsliste $clients, um alle verbundenen Clients aufzuzeichnen. In der onOpen-Methode fügen wir die neue Verbindung zur Verbindungsliste hinzu und zeichnen die Ressourcen-ID der Verbindung auf. Bei der onMessage-Methode durchlaufen wir alle Verbindungen und senden die empfangene Nachricht an alle Clients außer dem Absender. Die Methoden onClose und onError werden zur Behandlung von Verbindungsschließungen und Fehlersituationen verwendet.

Schritt drei: Server ausführen

Bevor wir den Server ausführen, müssen wir den WebSocket-Server im Terminal starten. Sie können im Projektverzeichnis ein Startskript erstellen, um den Server zu starten. Im Startskript müssen wir ein WebSocket-Serverobjekt erstellen und dann eine Instanz der Serverklasse an das WebSocket-Serverobjekt übergeben. Hier ist ein Beispiel für ein Startskript:

use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;

require dirname(__DIR__) . '/vendor/autoload.php';

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

$server->run();

Im obigen Beispiel haben wir ein WebSocket-Serverobjekt $server erstellt, das Port 8080 überwacht. HttpServer und WsServer sind zwei Komponenten in der Ratchet-Bibliothek, die HTTP-Anfragen und WebSocket-Verbindungen verarbeiten. Wir übergeben eine Instanz der Chat-Klasse an WsServer, um verwandte Ereignisse zu verarbeiten, nachdem die WebSocket-Verbindung hergestellt wurde. Starten Sie abschließend den WebSocket-Server, indem Sie die Methode $server->run() aufrufen.

4. Echtzeit-Webanwendungen mit WebSocket entwickeln

Nachdem wir den WebSocket-Server mit PHP erstellt haben, können wir mit der Entwicklung von Echtzeit-Webanwendungen beginnen. Der WebSocket-Server kann alle verbundenen Clients aufzeichnen und beim Empfang einer Nachricht von einem Client die Nachricht an alle Clients senden. Wir können JavaScript verwenden, um auf der Clientseite Code zu schreiben, eine WebSocket-Verbindung herzustellen und Daten zu senden und zu empfangen.

Das Folgende ist ein Beispielcode zum Herstellen einer WebSocket-Verbindung mit jQuery:

let websocket = new WebSocket('ws://localhost:8080');

websocket.onmessage = function(event) {
    console.log(event.data);
}

$('form').submit(function(event) {
    event.preventDefault();
    let message = $('input').val();
    $('input').val('');
    websocket.send(message);
});

Im obigen Beispiel verwenden wir den WebSocket-Konstruktor, um eine WebSocket-Verbindung herzustellen, und die Verbindungsadresse lautet ws://localhost:8080. In der Funktion onmessage hören wir das WebSocket-Nachrichtenereignis ab und geben die Nachricht nach dem Empfang an die Konsole aus. Beim Formular-Übermittlungsereignis erhalten wir den Text im Eingabefeld und senden ihn an den WebSocket-Server.

5. Fazit

WebSocket ist ein Protokoll, das Echtzeitkommunikation erreichen kann und sich durch hohe Effizienz und Echtzeitleistung auszeichnet. In PHP können wir mit Hilfe der Ratchet-Bibliothek ganz einfach einen WebSocket-Server erstellen, wodurch die Entwicklung von Echtzeit-Webanwendungen einfacher und effizienter wird. In Zukunft wird das WebSocket-Protokoll ein wichtiger Bestandteil der Echtzeit-Webanwendungsentwicklung sein.

Das obige ist der detaillierte Inhalt vonErstellen Sie Echtzeit-Webanwendungen mit WebSockets in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!