So verwenden Sie PHP und WebSocket zur Implementierung von Instant-Messaging-Funktionen

In der heutigen Zeit der rasanten Entwicklung des Internets steigt die Nachfrage nach Instant Messaging. Um den Bedürfnissen der Benutzer gerecht zu werden und das Benutzererlebnis zu verbessern, verfügen viele Websites über integrierte Instant-Messaging-Funktionen. Wie kann man also PHP und WebSocket verwenden, um die Instant-Messaging-Funktion zu implementieren? In diesem Artikel erhalten Sie eine detaillierte Einführung in die Schritte zur Verwendung von PHP und WebSocket zur Implementierung von Instant-Messaging-Funktionen.

1. Verstehen Sie das WebSocket-Protokoll

WebSocket ist ein neues Netzwerkkommunikationsprotokoll, das auf dem TCP-Protokoll basiert. Es kann eine bidirektionale Kommunikation zwischen dem Client und dem Server erreichen, wie sie beispielsweise in Instant-Messaging-Szenarien verwendet wird. Beim herkömmlichen HTTP-Protokoll muss der Client Daten erhalten, indem er eine Anfrage an den Server sendet, während bei WebSocket eine dauerhafte Verbindung zwischen Client und Server hergestellt wird und Daten jederzeit aneinander gesendet werden können.

Bevor Sie WebSocket zum Implementieren von Instant-Messaging-Funktionen verwenden, müssen Sie das WebSocket-Protokoll und seine Vor- und Nachteile verstehen. Im Folgenden sind einige Vorteile des WebSocket-Protokolls aufgeführt:

1 Durch eine dauerhafte Verbindung kann schnell eine bidirektionale Kommunikation erreicht und der Bandbreitenverbrauch reduziert werden.

2. Durch die Reduzierung von HTTP-Anfragen kann die Serverleistung verbessert werden.

3. Kompatibilitätstests können in verschiedenen Browsern durchgeführt werden und unterstützen mehrere Browser.

4. Kann durch eine Vielzahl von Programmiersprachen implementiert werden.

Aber gleichzeitig weist das WebSocket-Protokoll auch einige Mängel auf:

1 Es wird noch nicht von allen Mainstream-Browsern unterstützt. Beispielsweise können Browser mit niedrigeren IE-Versionen das WebSocket-Protokoll nicht unterstützen.

2. Wenn die WebSocket-Verbindung ausfällt, müssen sowohl der Server als auch der Client die Verbindung wiederherstellen.

3. Sicherheit und Datenschutz müssen gewährleistet sein, um Datenlecks und andere Probleme zu verhindern.

4. Es kann die Belastung des Systems erhöhen.

2. So implementieren Sie WebSocket in PHP

1. Verwenden Sie die Ratchet-Bibliothek

Ratchet ist eine Bibliothek für PHP zur Implementierung des WebSocket-Protokolls. Ratchet kann in einer Vielzahl von Umgebungen verwendet werden, beispielsweise in Symfony- und Laravel-Frameworks. Der Vorteil der Verwendung von Ratchet besteht darin, dass Sie WebSocket-Funktionen schnell implementieren und gleichzeitig die Entwicklungsschwierigkeiten und die Arbeitsbelastung der zugrunde liegenden Details reduzieren können.

Hier sind die Schritte zum Implementieren von WebSocket mit Ratchet:

(1) Installieren Sie die Ratchet-Bibliothek

Bevor Sie die Ratchet-Bibliothek verwenden, müssen Sie das Composer-Tool auf Ihrem Computer installieren. Installieren Sie nach der Installation von Composer die Ratchet-Bibliothek über das Befehlszeilentool:

composer require cboden/ratchet

(2) Erstellen Sie einen WebSocket-Server

Nach der Installation der Ratchet-Bibliothek müssen Sie einen WebSocket-Server erstellen. Hier ist eine einfache Hello World-Anwendung:

<?php
use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;
use MyAppWebSocketApplication;

require __DIR__ . '/vendor/autoload.php';

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

$server->run();

Im obigen Code ist WebSocketApplication die WebSocket-Anwendungsklasse, die Sie selbst schreiben müssen. Das Erstellen einer WebSocket-Anwendungsklasse erfordert die Implementierung der MessageComponentInterface-Schnittstelle. Die kritischste Methode ist onMessage(), die aufgerufen wird, wenn eine Client-Nachricht empfangen wird.

<?php
namespace MyApp;
use RatchetMessageComponentInterface;
use RatchetConnectionInterface;

class WebSocketApplication 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 ($from !== $client) {
                $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();
    }
}

(3) Testen Sie den WebSocket-Server

Nach Abschluss der obigen Schritte können Sie zum Testen den WebSocket-Client im Browser oder zum Testen den WebSocket-Client in der Befehlszeile verwenden.

2. Verwenden Sie die Swoole-Erweiterung.

Eine andere Möglichkeit für PHP, das WebSocket-Protokoll zu implementieren, ist die Verwendung der Swoole-Erweiterung. Swoole ist ein leistungsstarkes Netzwerkkommunikations-Framework, das WebSocket-Funktionen schnell implementieren kann. Es bietet außerdem Coroutine, asynchrones MySQL und andere Funktionen zur Verbesserung der Leistung.

Im Folgenden sind die Schritte zum Implementieren von WebSocket mithilfe der Swoole-Erweiterung aufgeführt:

(1) Installieren Sie die Swoole-Erweiterung.

Zuerst müssen Sie die Swoole-Erweiterung auf Ihrem Computer installieren. Führen Sie nach der Installation der Swoole-Erweiterung die Swoole-Bibliothek in das PHP-Skript ein:

require "vendor/autoload.php";

(2) Erstellen Sie einen WebSocket-Server

Der Kerncode für die Verwendung von Swoole zur Implementierung von WebSocket lautet wie folgt:

$server = new SwooleWebSocketServer("127.0.0.1", 8080);

$server->on('open', function (SwooleWebSocketServer $server, $request) {
    echo "server: handshake success with fd{$request->fd}
";
});

$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    echo "receive from {$frame->fd}:{$frame->data},opcode:{$frame->opcode},fin:{$frame->finish}
";
    $server->push($frame->fd, "this is server :" . date("Y-m-d H:i:s"));
});

$server->on('close', function ($ser, $fd) {
    echo "client {$fd} closed
";
});

$server->start();

Im obigen Code ist der on Die Methode wird zum Registrieren von Öffnungs-, Nachrichten-, Schließ- und anderen Ereignissen verwendet. Nachdem der Client eine Verbindung zum WebSocket-Server hergestellt hat, ruft der Server das Öffnungsereignis zurück. Wenn der Client eine Nachricht sendet, ruft der Server das Nachrichtenereignis zurück, um die vom Client gesendete Nachricht zu verarbeiten. Am Ende, wenn der Client die WebSocket-Verbindung schließt, ruft der Server das Schließereignis zurück.

3. WebSocket-Kommunikationstoolklasse kapseln

Um die Wiederverwendbarkeit von Code zu verbessern, können wir die WebSocket-Kommunikationsfunktion in einer Toolklasse kapseln, sodass andere Codes die WebSocket-Kommunikation einfach implementieren können, indem sie die Toolklassenmethode aufrufen.

Das Folgende ist eine einfache WebSocket-Dienstprogrammklasse:

<?php
namespace MyApp;

use RatchetClientWebSocket;
use RatchetRFC6455MessagingFrame;
use ReactEventLoopFactory;
use ReactSocketConnector;
use ReactSocketConnectionInterface;

class WebSocketClient
{
    private $client;
    private $loop;

    public function __construct(string $url)
    {
        $this->loop = Factory::create();
        $this->client = new WebSocket($url, [], $this->loop);
    }

    /**
     * @param $data
     * @param int $opcode
     * @param bool $fin
     */
    public function send($data, $opcode = Frame::OP_TEXT, bool $fin = true)
    {
        $this->client->send(new Frame($data, true, $opcode, $fin));
    }

    /**
     * @return WebSocket
     */
    public function getClient(): WebSocket
    {
        return $this->client;
    }

    /**
     * @return ReactEventLoopLoopInterface
     */
    public function getLoop(): ReactEventLoopLoopInterface
    {
        return $this->loop;
    }

    /**
     * @param ConnectionInterface $conn
     */
    public function onClose(ConnectionInterface $conn)
    {
        echo "Connection closed: {$conn->getRemoteAddress()}
";
    }

    public function run()
    {
        $this->client->connect()
            ->then(function (WebSocket $conn) {
                echo "Connected
";
                $this->send('Hello, World!');
                $conn->on('message', function (Frame $msg) use ($conn) {
                    echo "Received: {$msg}
";
                    $conn->close();
                });
                $conn->on('close', function ($code = null, $reason = null) {
                    echo "Connection closed ({$code} - {$reason})
";
                });
            }, function (Throwable $e) {
                echo "Could not connect: {$e->getMessage()}
";
            });

        $this->loop->run();
    }
}

Im obigen Code definieren wir die WebSocketClient-Klasse, die einen WebSocket-Client erstellen und eine Verbindung zum angegebenen Server herstellen kann. Gleichzeitig werden auch Methoden wie send und onClose bereitgestellt, um Daten zu senden und Ereignisse beim Schließen von WebSocket-Verbindungen zu verarbeiten. Nach der Erstellung des WebSocket-Clients haben wir den Promise-Modus verwendet, um das Verbindungsereignis zu verarbeiten, auf Nachrichten- und Schließereignisse zu warten und die entsprechenden Ereignisse zu verarbeiten, wenn sie ausgelöst werden.

4. Zusammenfassung

Dieser Artikel stellt Ihnen detailliert vor, wie Sie PHP und WebSocket zur Implementierung von Instant-Messaging-Funktionen verwenden, und erläutert die Merkmale und Mängel des WebSocket-Protokolls. Mithilfe der Ratchet-Bibliothek und der Swoole-Erweiterung können Sie die WebSocket-Funktionalität schnell implementieren. Um die Wiederverwendbarkeit der WebSocket-Kommunikation zu verbessern, zeigen wir Ihnen gleichzeitig auch, wie Sie die WebSocket-Client-Kommunikationstoolklasse kapseln. Ich hoffe, dieser Artikel ist hilfreich für Sie. Vielen Dank für das Lesen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie PHP und WebSocket zur Implementierung von Instant-Messaging-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!