Erstellung einer High-Performance PHP-Anwendung mit Swoole
Was ist Swoole?
Swoole ist ein leistungsstarkes Netzwerkkommunikations-Framework für PHP, das asynchrone, mehrsträngige und Koroutinen-Funktionen bietet, sodass PHP wie Node.js hochkonkurrente Aufgaben bewältigen kann. Es unterstützt mehrere Protokolle wie TCP, UDP, UnixSocket, HTTP, WebSocket usw. und eignet sich zum Aufbau leistungsstarker Webserver, Microservice-Architekturen, Echtzeit-Kommunikationssysteme und mehr.
Hauptmerkmale und Vorteile von Swoole
- Hohe Leistung: Swoole ist in C geschrieben, was zu einer extrem hohen Leistung führt. Es unterstützt asynchrone I/O und Koroutinen, um hohe Konkurrenzanfragen zu verarbeiten.
- Reichhaltige Funktionen: Unterstützung für verschiedene Netzwerkprotokolle, Timer, Prozessverwaltung, Speichermanagement und mehr, um unterschiedlichen Entwicklungsanforderungen gerecht zu werden.
- Benutzerfreundlich: Bietet eine einfach zu bedienende API und reichhaltige Dokumentation, um Entwicklern den Einstieg zu erleichtern.
- Hohe Erweiterbarkeit: Unterstützt benutzerdefinierte Erweiterungen und Plugins und kann flexibel an die Anforderungen angepasst werden.
Swoole ist die ideale Wahl für den Aufbau von hochleistungsfähigen Webanwendungen und Echtzeit-Kommunikationssystemen und eignet sich für Projekte aller Größen, von kleinen Anwendungen bis hin zu großen unternehmensweiten Systemen.
Installation von Swoole
In diesem Artikel stellen wir vor, wie Sie Swoole in der ServBay-Umgebung installieren und verwenden.
TIP
ServBay empfiehlt Entwicklern, ihre Websites im Verzeichnis /Applications/ServBay/www
abzulegen, um die Verwaltung zu erleichtern.
Schritt 1: Swoole-Erweiterung installieren
Swoole-Erweiterung aktivieren
ServBay hat die Swoole-Erweiterung bereits eingebaut. Benutzer müssen diese aktivieren und PHP neu starten. Bitte lesen Sie den Artikel Wie man das integrierte Swoole-Modul von ServBay aktiviert, um das Swoole-Modul zu aktivieren.
Schritt 2: Projektverzeichnis erstellen
Erstellen Sie ein Projektverzeichnis und wechseln Sie in dieses:
cd /Applications/ServBay/www
mkdir servbay-swoole-app
cd servbay-swoole-app
2
3
Schritt 3: Swoole-Serverskript erstellen
Erstellen Sie im Projektverzeichnis eine Datei server.php
und schreiben Sie einen einfachen Swoole-HTTP-Server:
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
$server = new Server("0.0.0.0", 9501);
$server->on("start", function (Server $server) {
echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) {
$response->header("Content-Type", "text/plain");
$response->end("Hello ServBay!");
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Schritt 4: Swoole-Server starten
Führen Sie im Terminal den folgenden Befehl aus, um den Swoole-Server zu starten:
php server.php
Sie werden die folgende Ausgabe sehen:
Swoole HTTP server is started at http://0.0.0.0:9501
Schritt 5: Swoole-Server besuchen
Öffnen Sie den Browser und besuchen Sie http://localhost:9501
. Sie werden die Ausgabe Hello ServBay!
sehen.
Erstellung einer Webanwendung mit Swoole
In diesem Abschnitt erklären wir, wie man mit Swoole eine einfache Webanwendung erstellt.
Controller und Routen erstellen
Erstellen Sie im Projektverzeichnis ein app
-Verzeichnis, und darin die Verzeichnisse controllers
und routes
:
mkdir -p app/controllers
mkdir -p app/routes
2
Erstellen Sie im Verzeichnis app/controllers
eine Datei namens HomeController.php
:
<?php
namespace App\Controllers;
class HomeController
{
public function index()
{
return "Welcome to ServBay!";
}
public function hello($name)
{
return "Hello, $name!";
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Erstellen Sie im Verzeichnis app/routes
eine Datei namens web.php
:
<?php
use App\Controllers\HomeController;
return [
'GET /' => [HomeController::class, 'index'],
'GET /hello/{name}' => [HomeController::class, 'hello'],
];
2
3
4
5
6
7
8
Swoole-Serverskript aktualisieren
Aktualisieren Sie die Datei server.php
, um Routing-Logik und Controller-Aufrufe hinzuzufügen:
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
use FastRoute\RouteCollector;
use function FastRoute\simpleDispatcher;
require 'vendor/autoload.php';
$server = new Server("0.0.0.0", 9501);
$routes = require __DIR__ . '/app/routes/web.php';
$dispatcher = simpleDispatcher(function (RouteCollector $r) use ($routes) {
foreach ($routes als $route => $handler) {
list($method, $path) = explode(' ', $route);
$r->addRoute($method, $path, $handler);
}
});
$server->on("start", function (Server $server) {
echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) use ($dispatcher) {
$routeInfo = $dispatcher->dispatch($request->server['request_method'], $request->server['request_uri']);
switch ($routeInfo[0]) {
case \FastRoute\Dispatcher::NOT_FOUND:
$response->status(404);
$response->end('404 Not Found');
break;
case \FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
$response->status(405);
$response->end('405 Method Not Allowed');
break;
case \FastRoute\Dispatcher::FOUND:
$handler = $routeInfo[1];
$vars = $routeInfo[2];
list($class, $method) = $handler;
$response->header("Content-Type", "text/plain");
$response->end(call_user_func_array([new $class, $method], $vars));
break;
}
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
FastRoute installieren
Führen Sie im Projektstammverzeichnis den folgenden Befehl aus, um die FastRoute-Routing-Bibliothek zu installieren:
composer require nikic/fast-route
Swoole-Server starten
Führen Sie im Terminal den folgenden Befehl aus, um den Swoole-Server zu starten:
php server.php
Webanwendung besuchen
Öffnen Sie den Browser und besuchen Sie die folgenden URLs:
http://localhost:9501/
: Sie werden die AusgabeWelcome to ServBay!
sehen.http://localhost:9501/hello/ServBay
: Sie werden die AusgabeHello, ServBay!
sehen.
Umgang mit WebSocket-Verbindungen in Swoole
Swoole unterstützt auch das WebSocket-Protokoll, das für den Aufbau von Echtzeit-Kommunikationsanwendungen genutzt werden kann. Wir erklären, wie man mit Swoole WebSocket-Verbindungen bearbeitet.
WebSocket-Serverskript erstellen
Erstellen Sie im Projektverzeichnis eine Datei namens websocket_server.php
und schreiben Sie einen einfachen WebSocket-Server:
<?php
use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
$server = new Server("0.0.0.0", 9502);
$server->on("start", function (Server $server) {
echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});
$server->on("open", function (Server $server, Request $request) {
echo "connection open: {$request->fd}\n";
});
$server->on("message", function (Server $server, Frame $frame) {
echo "received message: {$frame->data}\n";
$server->push($frame->fd, "Hello, {$frame->data}");
});
$server->on("close", function ($ser, $fd) {
echo "connection close: {$fd}\n";
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
WebSocket-Server starten
Führen Sie im Terminal den folgenden Befehl aus, um den WebSocket-Server zu starten:
php websocket_server.php
Sie werden die folgende Ausgabe sehen:
Swoole WebSocket server is started at ws://0.0.0.0:9502
Verbindung zum WebSocket-Server herstellen
Sie können entweder den WebSocket-Client im Browser oder andere WebSocket-Client-Tools (zum Beispiel wscat
) verwenden, um sich mit dem WebSocket-Server zu verbinden.
Verbindung mit wscat
Installieren Sie
wscat
:bashnpm install -g wscat
1Verbinden Sie sich mit dem WebSocket-Server:
bashwscat -c ws://localhost:9502
1Senden Sie eine Nachricht:
bash> Hello ServBay
1
Sie werden die vom Server zurückgegebene Nachricht sehen:
< Hello, Hello ServBay
Durch diese Schritte haben Sie erfolgreich ein Swoole-Projekt erstellt und betrieben und die von Swoole bereitgestellten Funktionen zum Umgang mit HTTP-Anfragen und WebSocket-Verbindungen genutzt. Die hohe Leistung und die reichhaltigen Funktionen von Swoole machen es zur idealen Wahl für den Aufbau hochkonkurrenter Anwendungen.