Hochleistungs-PHP-Anwendungen mit Swoole in ServBay erstellen
ServBay ist eine lokal installierte Web-Entwicklungsumgebung, die speziell für Entwickler konzipiert wurde. Sie enthält zahlreiche Programmiersprachen, Datenbanken und nützliche Tools, um lokale Entwicklungsabläufe deutlich zu vereinfachen. Dieser Artikel zeigt, wie Sie im ServBay-Umfeld mithilfe der Swoole-Erweiterung Ihre PHP-Anwendungen optimieren und performante Netzwerkdienste bereitstellen.
Was ist Swoole?
Swoole ist eine für PHP entwickelte, Coroutine-basierte, parallele und hochleistungsfähige Netzwerk-Engine. Komplett in C geschrieben, erweitert Swoole PHP um asynchrone, parallele und Coroutine-basierte Netzwerkkommunikation. Mit Swoole können PHP-Entwickler die Grenzen des klassischen Webserver-Modells (wie Apache/Nginx + PHP-FPM) überwinden und hochskalierende Aufgaben effizient ausführen – etwa den Bau von persistenten Webservern, asynchrone Aufgabenverarbeitung oder Echtzeitkommunikation (WebSocket).
Wichtige Vorteile von Swoole:
- Hochleistung: Dank C-Implementierung, asynchronem I/O, Multi-Prozess- und Multi-Thread-Unterstützung.
- Coroutinen: Bietet leichtgewichtige Coroutinen, sodass Sie mit synchronem Code asynchron programmieren und komplexe Ablaufmodelle vereinfachen können.
- Umfangreiche Protokollunterstützung: Nativ für TCP/UDP/HTTP/WebSocket und weitere Netzwerkprotokolle.
- Benutzerfreundlichkeit: Einfache und PHP-typische APIs für schnellen Einstieg.
- Dauerbetrieb: Anwendungen laufen als Daemon-Prozesse und vermeiden das wiederholte Initialisieren der PHP-Umgebung für jede Anfrage.
Mit Swoole avanciert PHP von einer klassischen Webscriptsprache zu einer vielseitigen Plattform für anspruchsvolle Netzwerkapplikationen.
Swoole in ServBay aktivieren
Ein Kernziel von ServBay ist, das Verwalten und Nutzen von PHP-Erweiterungen möglichst einfach zu machen. Swoole – eine Schlüsselkomponente für moderne PHP-Hochleistungsentwicklung – ist in ServBay bereits vorkompiliert enthalten. Die Aktivierung gelingt in wenigen Schritten.
Voraussetzungen:
- ServBay ist installiert und läuft.
- Mindestens eine PHP-Version ist in ServBay vorhanden.
Aktivierungsschritte:
- Öffnen Sie das ServBay-Oberflächenprogramm.
- Wechseln Sie zu „Pakete (Packages)“ oder zur PHP-Versionenverwaltung. (Je nach ServBay-Version unterscheiden sich die Menüpunkte; meist zu finden im Hauptfenster oder unter Einstellungen.)
- Wählen Sie die PHP-Version, für die Swoole aktiviert werden soll.
- Suchen Sie die Swoole-Erweiterung und schalten Sie sie ein. ServBay bietet die Extensions meist als Liste oder Schalter an.
- Speichern Sie die Änderung und starten Sie ggf. ServBay oder den betroffenen PHP-Dienst neu. ServBay passt die Konfiguration automatisch an, damit Swoole geladen wird.
Nach erfolgreicher Aktivierung können Sie Swoole in Ihrer gewählten PHP-Version direkt nutzen. Prüfen Sie die geladene Erweiterung auch via Kommandozeile mit php -m
– taucht swoole
in der Liste auf, ist alles korrekt eingerichtet.
TIP
ServBay empfiehlt standardmäßig die Ablage Ihrer Webseiten und Projekte in folgenden Verzeichnissen, was die Verwaltung und Konfiguration erleichtert:
- macOS:
/Applications/ServBay/www
- Windows:
C:\ServBay\www
Die Beispiele in diesem Artikel verwenden ebenfalls diese Pfade.
Einen einfachen Swoole-HTTP-Server erstellen
Im folgenden Beispiel setzen wir einen simplen HTTP-Server mit Swoole auf, der HTTP-Anfragen verarbeitet.
Schritt 1: Projektverzeichnis anlegen
Öffnen Sie Ihr Terminal, erstellen Sie ein neues Projektverzeichnis und wechseln Sie hinein. Verwenden Sie den empfohlenen Pfad Ihres Betriebssystems:
macOS:
bash
cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http
1
2
3
2
3
Windows:
cmd
cd C:\ServBay\www
mkdir servbay-swoole-http
cd servbay-swoole-http
1
2
3
2
3
Schritt 2: Serverskript schreiben
Erstellen Sie in Ihrem Projektordner servbay-swoole-http
die Datei server.php
. Ergänzen Sie darin folgenden PHP-Code:
php
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
// Swoole HTTP-Server-Instanz erstellen
// Lauscht auf Port 9501 aller Netzwerkinterfaces (0.0.0.0)
$server = new Server("0.0.0.0", 9501);
// Callback für das 'start'-Event registrieren
// Ausgelöst wenn der Server erfolgreich startet
$server->on("start", function (Server $server) {
echo "Swoole HTTP-Server läuft unter http://0.0.0.0:9501\n";
// Hier können Hauptprozess-ID, Manager-ID etc. ausgegeben/geloggt werden
});
// Callback für das 'request'-Event registrieren
// Ausgelöst bei jedem HTTP-Request
$server->on("request", function (Request $request, Response $response) {
// Response-Header setzen
$response->header("Content-Type", "text/plain");
// Logik basierend auf Anfrage-Pfad oder -Parametern
$path = $request->server['request_uri'] ?? '/';
$content = "Hello ServBay!";
if ($path === '/info') {
$content = "Request path: " . $path . "\n";
$content .= "Method: " . $request->server['request_method'] . "\n";
$content .= "Client IP: " . $request->server['remote_addr'] . "\n";
// Weitere Anfrageinfos via $request abrufbar
}
// Antwort senden und Anfrage beenden
$response->end($content);
});
// Server starten
$server->start();
1
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
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
Dieses Skript startet einen Swoole-HTTP-Server auf Port 9501 und liefert bei jeder Anfrage eine einfache Textnachricht „Hello ServBay!“. Bei Aufruf von /info
werden detaillierte Request-Daten zurückgegeben.
Schritt 3: Swoole-Server starten
Stellen Sie sicher, dass Ihr Terminal im Verzeichnis servbay-swoole-http
ist, und führen Sie das Skript mit der in ServBay aktivierten PHP-Version aus:
bash
php server.php
1
Nach erfolgreichem Start sehen Sie im Terminal:
bash
Swoole HTTP-Server läuft unter http://0.0.0.0:9501
1
Ihr Swoole-HTTP-Server ist nun im Hintergrund auf Port 9501 aktiv.
Schritt 4: Server im Browser ansprechen
Öffnen Sie einen Webbrowser und rufen Sie folgende Adressen auf:
http://localhost:9501
http://localhost:9501/info
Im Browser erscheint jeweils die Textausgabe „Hello ServBay!“ bzw. eine Übersicht der Request-Daten.
Um den Server zu stoppen, drücken Sie im Terminal, in dem das Skript läuft, einfach Ctrl + C
.
WebSocket-Verbindungen mit Swoole verarbeiten
Swoole unterstützt das WebSocket-Protokoll nativ. Damit lassen sich beispielsweise Echtzeit-Chaträume, Game-Server oder Live-Daten-Push effizient umsetzen.
Schritt 1: WebSocket-Server-Skript schreiben
Legen Sie in Ihrem Projektverzeichnis (z. B. servbay-swoole-http
oder einem neuen Ordner wie servbay-swoole-websocket
) eine Datei namens websocket_server.php
an und fügen Sie folgendes ein:
Projektverzeichnis-Pfade:
- macOS:
/Applications/ServBay/www/servbay-swoole-http
- Windows:
C:\ServBay\www\servbay-swoole-http
php
<?php
use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
// Swoole WebSocket-Server erstellen
// WebSocket-Server erbt von HTTP-Server und kann daher auch HTTP-Anfragen verarbeiten
$server = new Server("0.0.0.0", 9502); // Lauscht auf Port 9502
// 'start'-Event registrieren, ausgelöst falls Server startet
$server->on("start", function (Server $server) {
echo "Swoole WebSocket-Server läuft unter ws://0.0.0.0:9502\n";
});
// 'open'-Event
// Ausgelöst bei neuer WebSocket-Verbindung
// $request enthält Infos wie $request->fd (Client File Descriptor)
$server->on("open", function (Server $server, Request $request) {
echo "Verbindung geöffnet: {$request->fd}\n";
// Willkommensnachricht an den Client senden
$server->push($request->fd, "Willkommen beim ServBay WebSocket Demo!");
});
// 'message'-Event
// Ausgelöst bei Empfang einer Nachricht vom Client
// $frame enthält u. a. $frame->data für Nachrichteninhalt, $frame->fd für den Client
$server->on("message", function (Server $server, Frame $frame) {
echo "Nachricht erhalten von {$frame->fd}: {$frame->data}\n";
// Nachricht an den Sender zurückschicken
$server->push($frame->fd, "Hallo, deine Nachricht: {$frame->data}");
// Beispiel für Broadcast (Verbindungsverwaltung oder Iteration nötig)
// foreach ($server->connections as $fd) {
// if ($fd != $frame->fd) { // Sender nicht erneut beschicken
// $server->push($fd, "Benutzer {$frame->fd} sagt: {$frame->data}");
// }
// }
});
// 'close'-Event
// Ausgelöst wenn Verbindung vom Client geschlossen wird
$server->on("close", function ($ser, $fd) {
echo "Verbindung geschlossen: {$fd}\n";
});
// Server starten
$server->start();
1
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
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
Das Skript startet einen WebSocket-Server auf Port 9502 mit Callbacks für die wichtigsten Events: start
(Serverstart), open
(neue Verbindung), message
(Nachricht erhalten), close
(Verbindung beendet). Im message
-Callback sendet der Server die empfangene Nachricht mit Präfix zurück an den Absender.
Schritt 2: WebSocket-Server starten
Öffnen Sie ein Terminal im Verzeichnis der Datei websocket_server.php
und führen Sie das Skript mit dem in ServBay aktivierten PHP aus:
bash
php websocket_server.php
1
Bei erfolgreichem Start sehen Sie im Terminal:
bash
Swoole WebSocket-Server läuft unter ws://0.0.0.0:9502
1
Ihr WebSocket-Server ist nun bereit und wartet auf Verbindungen am Port 9502.
Schritt 3: Verbindung zum WebSocket-Server herstellen
Es gibt mehrere Möglichkeiten, die Verbindung zum WebSocket-Server testweise herzustellen.
Methode A: Browser-Entwicklertools verwenden
Die meisten modernen Browser bieten im Entwicklerbereich (Tastenkürzel meist F12) einen „Netzwerk“- oder „Konsole“-Tab zum Testen von WebSocket-Verbindungen.
Eine beliebige Webseite öffnen (z. B.
about:blank
).Entwicklerkonsole öffnen und zum „Konsole“-Tab wechseln.
Folgenden JavaScript-Code eingeben:
javascriptvar ws = new WebSocket("ws://localhost:9502"); ws.onopen = function(event) { console.log("WebSocket-Verbindung geöffnet:", event); ws.send("Hallo vom Browser!"); // Nachricht nach Verbindungsaufbau senden }; ws.onmessage = function(event) { console.log("Nachricht vom Server:", event.data); // Empfangene Daten }; ws.onerror = function(event) { console.error("WebSocket-Fehler:", event); // Fehlerbehandlung }; ws.onclose = function(event) { console.log("WebSocket-Verbindung geschlossen:", event); // Verbindung beendet }; // Zusätzliche Nachrichten senden via ws.send("Deine Nachricht") // Verbindung schließen mit ws.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21Starten Sie den Code in der Console und beobachten Sie die Ausgaben sowie die Logs im Terminal, in dem
websocket_server.php
läuft.
Methode B: Mit dem wscat
-Kommandozeilentool
wscat
ist ein praktischer WebSocket-Client für die Kommandozeile, basierend auf Node.js.
Installation von
wscat
: Falls Node.js und npm noch nicht installiert sind, zuerst installieren. Dannwscat
global via npm installieren:bashnpm install -g wscat
1Mit WebSocket-Server verbinden: Im Terminal eingeben:
bashwscat -c ws://localhost:9502
1Nach Verbindungsaufbau erscheint die Eingabeaufforderung
>
.Nachricht senden: Geben Sie eine beliebige Nachricht nach
>
ein und drücken Sie Enter:bash> Hallo ServBay via wscat
1Der Server antwortet, die Antwort wird mit
<
angezeigt:bash< Hallo, deine Nachricht: Hallo ServBay via wscat
1Im Terminal des WebSocket-Servers werden die Events ebenfalls geloggt.
Trennen Sie die Verbindung mit Ctrl + C
.
Wichtige Hinweise
- Portkonflikte: Sorgen Sie dafür, dass die von Swoole genutzten Ports (wie 9501, 9502) nicht von anderen Anwendungen belegt sind. Im Konfliktfall startet der Server nicht.
- PHP-Version: Nutzen Sie zum Ausführen der Skripte die PHP-Version mit aktivierter Swoole-Erweiterung aus ServBay. Überprüfen Sie die Version via
php -v
. ServBay bietet ggf. ein Umschalt-Tool für verschiedene PHP-Installationen. - Erweiterungsstatus: Startet der Server nicht, prüfen Sie, ob Swoole für die aktuelle PHP-Version korrekt aktiviert wurde und ob ServBay/PHP-Dienst nach Änderungen neu gestartet wurde.
- Verwaltung von Dauerprozessen: Swoole-Server laufen dauerhaft im Speicher. In produktiven Umgebungen sollte ein Prozessmanager wie Supervisor, Systemd oder pm2 verwendet werden, um nach Abstürzen automatischen Restart sicherzustellen. Für lokale Entwicklung reicht der manuelle Start im Terminal meist aus.
Fazit
Dank ServBay können Sie Swoole-Erweiterungen unkompliziert aktivieren und leistungsfähige PHP-Anwendungen lokal testen – egal ob klassische HTTP-Server oder moderne, echtzeitfähige WebSocket-Dienste. Die Synergie aus Swoole und einer bequemen Entwicklungsumgebung wie ServBay eröffnet neue Möglichkeiten für PHP-Entwickler und hilft Ihnen, skalierbare und effiziente Applikationen zu bauen. Probieren Sie Swoole in ServBay gleich heute aus!