Swoole Advanced: Coroutinen zum Schreiben gleichzeitiger Server verwenden

In Netzwerkanwendungsszenarien mit hoher Parallelität wird Swoole als weitreichendes Prozesskommunikations-Framework von Entwicklern zunehmend bevorzugt. Swoole bietet eine umfangreiche Netzwerkprogrammier-API, die es Entwicklern ermöglicht, Coroutinen für die asynchrone Programmierung zu verwenden und so die Möglichkeiten der gleichzeitigen Verarbeitung zu verbessern. In diesem Artikel wird erläutert, wie Sie mit Swoole und Coroutinen einen einfachen gleichzeitigen Server schreiben.

1. Umgebungseinrichtung

Bevor wir beginnen, müssen wir die Swoole-Erweiterung installieren. Informationen zur Installationsmethode finden Sie in der offiziellen Dokumentation von Swoole. Dieser Artikel verwendet die PHP7.2-Version.

2. Serverprogramm-Framework

Wir müssen den TCP-Server von Swoole verwenden. Die spezifische Implementierung muss die folgenden Aspekte berücksichtigen:

1. Definieren Sie das Protokollformat

In Netzwerkanwendungen ist es normalerweise erforderlich, Standarddaten zu definieren Übertragungsformat. In diesem Beispiel können wir ein benutzerdefiniertes Protokollformat verwenden, wie unten gezeigt:

class MyProtocol {
    const HEADER_SIZE = 4;
    const MAX_PACKAGE_SIZE = 1024 * 1024;

    public static function encode($data) {
        $package = json_encode($data, JSON_UNESCAPED_UNICODE);
        return pack('N', strlen($package)) . $package;
    }

    public static function decode($buffer) {
        if(strlen($buffer) < self::HEADER_SIZE) {
            return false;
        }

        $length = unpack('N', substr($buffer, 0, self::HEADER_SIZE))[1];
        if($length > self::MAX_PACKAGE_SIZE) {
            return false;
        }

        if(strlen($buffer) < self::HEADER_SIZE + $length) {
            return false;
        }

        $package = substr($buffer, self::HEADER_SIZE, $length);
        return json_decode($package, true);
    }
}

Das Protokollformat enthält einen 4-Byte-Header zum Speichern der Länge des Pakets und einen JSON-String, der die tatsächlichen Daten darstellt. Dieses Format kann verschiedene Nachrichtentypen unterstützen und Übertragungszuverlässigkeit und Skalierbarkeit erreichen.

2. Geschäftsverarbeitung definieren

Die Geschäftslogikverarbeitung wird in der Rückruffunktion der Server-Klasse definiert, wie unten gezeigt:

class Server {
    private $serv;

    public function __construct() {
        $this->serv = new SwooleServer('0.0.0.0', 9501);
        $this->serv->set(array(
            'worker_num' => 4,
            'daemonize' => false,
            'max_conn' => 10000,
            'dispatch_mode' => 3,
            'open_tcp_keepalive' => 1,
            'tcp_keepidle' => 600,
            'tcp_keepinterval' => 60,
            'tcp_keepcount' => 5,
        ));
        $this->serv->on('Connect', array($this, 'onConnect'));
        $this->serv->on('Receive', array($this, 'onReceive'));
        $this->serv->on('Close', array($this, 'onClose'));
        $this->serv->start();
    }

    public function onConnect($serv, $fd, $reactorId) {
        echo "Client: {$fd}-{$reactorId} Connect.
";
    }

    public function onReceive($serv, $fd, $reactorId, $data) {
        $message = MyProtocol::decode($data);
        if($message) {
            // Handle message & reply to client
            $this->serv->send($fd, MyProtocol::encode(array('status' => 0, 'message' => 'OK')));
        } else {
            // Invalid message, close connection
            $this->serv->close($fd);
        }
    }

    public function onClose($serv, $fd, $reactorId) {
        echo "Client: {$fd}-{$reactorId} Close.
";
    }
}

new Server();

Für jede Verbindung muss der Server drei Methoden definieren, um seine Verbindung zu verarbeiten, Nachrichten zu akzeptieren und zu schließen die Verbindung und andere Vorgänge und reagieren entsprechend.

3. Verwenden Sie Coroutinen

Swoole bietet eine Coroutine-API, um den Kontrollfluss in der asynchronen Programmierung zu verwalten und ein synchrones Programmiererlebnis zu bieten. Coroutine-Funktionen können über die API der Coroutine-Serie implementiert werden. Das Folgende ist der neue Code nach der Verwendung der Coroutine, der die Coroutine verwendet, um asynchrone E/A-Vorgänge wie Clientverbindungen und Nachrichtenempfang abzuwickeln:

class Server {
    private $serv;

    public function __construct() {
        $this->serv = new SwooleServer('0.0.0.0', 9501);
        $this->serv->set(array(
            'worker_num' => 4,
            'daemonize' => false,
            'max_conn' => 10000,
            'dispatch_mode' => 3,
            'open_tcp_keepalive' => 1,
            'tcp_keepidle' => 600,
            'tcp_keepinterval' => 60,
            'tcp_keepcount' => 5,
        ));
        $this->serv->on('Connect', array($this, 'onConnect'));
        $this->serv->on('Receive', array($this, 'onReceive'));
        $this->serv->on('Close', array($this, 'onClose'));
        $this->serv->start();
    }

    public function onConnect($serv, $fd, $reactorId) {
        go(function() use($fd, $reactorId) {
            echo "Client: {$fd}-{$reactorId} Connect.
";
        });
    }

    public function onReceive($serv, $fd, $reactorId, $data) {
        go(function() use($serv, $fd, $reactorId, $data) {
            $message = MyProtocol::decode($data);
            if($message) {
                // Handle message & reply to client
                $serv->send($fd, MyProtocol::encode(array('status' => 0, 'message' => 'OK')));
            } else {
                // Invalid message, close connection
                $serv->close($fd);
            }
        });
    }

    public function onClose($serv, $fd, $reactorId) {
        go(function() use($fd, $reactorId) {
            echo "Client: {$fd}-{$reactorId} Close.
";
        });
    }
}

new Server();

Verwenden Sie go(function()), um der Coroutine Aufgaben zur Ausführung hinzuzufügen und so die Menge zu reduzieren von Code, während unnötige Rückruffunktionen und die umständlichen Vorgänge manueller Verwaltungskontrollprozesse vermieden werden.

4. So führen Sie die Bereitstellung durch: Mit dem von Swoole bereitgestellten Befehlszeilentool können wir den Prozess der Ausführung des Servers einfach verwalten. So starten wir beispielsweise einen Swoole-TCP-Server wie folgt:

php server.php

Wenn Sie den Server im Hintergrund laufen lassen müssen, können Sie die Daemonisierungsoption festlegen:

php server.php --daemonize

Verwenden Sie zum Starten die von Swoole bereitgestellten Befehlszeilentools , Neustart und Stopp des Servers und anderer Vorgänge:

swoole_server [start|stop|reload|restart|shutdown]

Durch die Verwendung von Swoole können wir problemlos effiziente gleichzeitige Netzwerkanwendungen implementieren. Der mit Coroutinen geschriebene Swoole TCP-Server vereinfacht nicht nur die Codestruktur, sondern weist auch eine höhere Leistung auf. Im Vergleich zu herkömmlichen Multiprozess- oder Multithread-Servern kann er eine bessere Verarbeitungsleistung erzielen und den Ressourcenverbrauch des Servers erheblich senken.

Das obige ist der detaillierte Inhalt vonSwoole Advanced: Coroutinen zum Schreiben gleichzeitiger Server verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!