Snel en krachtig PHP ontwikkelen met Swoole binnen ServBay

ServBay is een lokaal webontwikkelplatform dat speciaal is ontworpen voor ontwikkelaars. Het bevat standaard meerdere programmeertalen, databases en tools, en is bedoeld om het lokale ontwikkelproces te vereenvoudigen. In deze handleiding leer je hoe je de Swoole-extensie binnen ServBay benut om PHP-toepassingen te voorzien van krachtige netwerkfunctionaliteit.

Wat is Swoole?

Swoole is een coroutine-gebaseerde, parallelle en high-performance netwerkengine voor PHP. Geschreven in pure C, biedt het PHP asynchroon, parallel en coroutine-ondersteuning voor netwerkcommunicatie. Dankzij Swoole kunnen PHP-ontwikkelaars zich losmaken van het traditionele request-response servermodel (zoals Apache/Nginx + PHP-FPM) en efficiënter omgaan met hoge belasting. Denk aan servers die resident zijn in het geheugen, asynchrone taakverwerking en real-time communicatie (zoals WebSocket).

Kernkenmerken van Swoole:

• Hoge prestaties: Swoole is geschreven in C en biedt asynchrone I/O, multi-proces en multi-threading mogelijkheden.
• Coroutines: Lichtgewicht coroutines maken asynchrone uitvoering van synchronisatiecode mogelijk, wat eenvoudiger asynchroon programmeren betekent.
• Ruime protocolondersteuning: Ondersteunt natively TCP/UDP/HTTP/WebSocket en meer netwerkprotocollen.
• Eenvoudig te gebruiken: Beschikt over een eenvoudige API die aansluit bij PHP-ontwikkelaars.
• Resident in geheugen: Applicaties kunnen als permanente processen draaien, waardoor de overhead van het herhaaldelijk opstarten van de PHP-omgeving vervalt.

Met Swoole overstijgt PHP zijn traditionele rol als scripttaal voor webontwikkeling en wordt het geschikt voor een breed scala aan krachtige en schaalbare netwerkapplicaties.

Swoole inschakelen in ServBay

Een van de doelen van ServBay is het eenvoudiger maken van het beheer en gebruik van PHP-extensies. Swoole, onmisbaar voor moderne high-performance PHP-projecten, wordt standaard meegeleverd. Je activeert Swoole met slechts enkele eenvoudige stappen.

Benodigdheden:

• ServBay is geïnstalleerd en actief.
• Minimaal één PHP-versie is geïnstalleerd in ServBay.

Stappen om te activeren:

1. Open ServBay en ga naar het hoofdscherm.
2. Navigeer naar het “Packages” scherm of de PHP versiebeheerder. (Afhankelijk van de ServBay-versie kan de naam verschillen, maar je vindt het doorgaans op het hoofdscherm of bij de instellingen.)
3. Selecteer de PHP-versie waarin je Swoole wilt activeren.
4. Zoek de Swoole-extensie in de lijst en activeer hem met het selectievakje. ServBay toont gecompileerde extensies doorgaans als een lijst of met een schakelaar.
5. Sla je wijzigingen op en herstart ServBay of de betreffende PHP-service volgens de instructies. ServBay zorgt automatisch voor het configureren en laden van Swoole in je PHP-omgeving.

Na deze stappen kun je Swoole gebruiken in de geselecteerde PHP-versie. Je kunt via de command line controleren of de extensie geladen is met php -m—zoek naar swoole in de lijst.

TIP

ServBay raadt aan je websites en projectbestanden te plaatsen in de volgende mappen. Dit maakt sitebeheer binnen ServBay eenvoudiger:

• macOS: /Applications/ServBay/www
• Windows: C:\ServBay\www

Ook de voorbeelden in dit artikel volgen deze structuur.

Een eenvoudige Swoole HTTP-server bouwen

We maken nu een basis HTTP-server met Swoole die webverzoeken verwerkt.

Stap 1: Maak een map voor het project aan

Open je terminal en maak een nieuwe map. We kiezen de voorgestelde locatie van ServBay:

macOS:

cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http

Windows:

cd C:\ServBay\www
mkdir servbay-swoole-http
cd servbay-swoole-http

Stap 2: Maak het serverscript

Maak in de map servbay-swoole-http een nieuw bestand aan genaamd server.php en plak onderstaande code:

<?php

use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;

// Maak een Swoole HTTP-server instantie aan
// Luistert op alle netwerkinterfaces (0.0.0.0) poort 9501
$server = new Server("0.0.0.0", 9501);

// Registreer 'start' event callback
// Wordt getriggerd als de server succesvol start
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is gestart op http://0.0.0.0:9501\n";
    // Hier kun je bijvoorbeeld het master proces-ID, manager-ID loggen, etc.
});

// Registreer 'request' event callback
// Wordt uitgevoerd zodra er een nieuw HTTP-verzoek binnenkomt
$server->on("request", function (Request $request, Response $response) {
    // Stel response headers in
    $response->header("Content-Type", "text/plain");

    // Verwerk logica afhankelijk van het pad of parameters
    $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";
        // Meer requestinformatie kan via het $request-object worden opgehaald
    }

    // Verstuur de response en beëindig het verzoek
    $response->end($content);
});

// Start de server
$server->start();

Deze code maakt een Swoole HTTP-server die poort 9501 beluistert. Bij een verzoek stuurt hij een simpele tekst "Hello ServBay!" terug. Bezoek je het /info pad, dan krijg je extra informatie over het verzoek.

Stap 3: Start de Swoole-server

Zorg dat je terminal zich in de map servbay-swoole-http bevindt. Start het script met de PHP-versie waar Swoole in geactiveerd is:

php server.php

Als alles goed gaat, zie je deze uitvoer in je terminal:

Swoole HTTP server is gestart op http://0.0.0.0:9501

Dit betekent dat de server actief is en luistert op poort 9501.

Stap 4: Open de Swoole-server in je browser

Open een browser en ga naar:

• http://localhost:9501
• http://localhost:9501/info

Je ziet respectievelijk “Hello ServBay!” en de informatie over het verzoek.

Wil je de server stoppen? Ga dan naar de terminal en druk op Ctrl + C.

Swoole gebruiken voor WebSocket-verbindingen

Swoole biedt ingebouwde ondersteuning voor het WebSocket-protocol, ideaal voor realtime toepassingen zoals chatrooms, gameservers of het pushen van live data.

Stap 1: Maak een WebSocket-serverscript

Maak in je projectfolder (bijvoorbeeld servbay-swoole-http of een nieuwe map servbay-swoole-websocket) een bestand aan genaamd websocket_server.php:

Projectpad:

• macOS: /Applications/ServBay/www/servbay-swoole-http
• Windows: C:\ServBay\www\servbay-swoole-http

<?php

use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;

// Maak een Swoole WebSocket-server aan
// WebSocket server is een uitbreiding van de HTTP-server en kan dus ook HTTP-verzoeken verwerken
$server = new Server("0.0.0.0", 9502); // Luistert op poort 9502

// Registreer 'start' event, uitgevoerd als de server opstart
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server draait op ws://0.0.0.0:9502\n";
});

// Registreer 'open' event
// Wordt getriggerd als een nieuwe verbinding is gemaakt
// Het $request-object bevat clientinformatie, zoals $request->fd (file descriptor)
$server->on("open", function (Server $server, Request $request) {
    echo "verbinding geopend: {$request->fd}\n";
    // Verstuur welkomstbericht naar client
    $server->push($request->fd, "Welkom bij de ServBay WebSocket Demo!");
});

// Registreer 'message' event
// Uitgevoerd als er een WebSocket-bericht van de client binnenkomt
// $frame bevat de inhoud van het bericht en het file descriptor van de zender
$server->on("message", function (Server $server, Frame $frame) {
    echo "bericht ontvangen van {$frame->fd}: {$frame->data}\n";
    // Beantwoord het bericht of broadcast naar alle clients
    // Bijvoorbeeld: antwoord aan de afzender
    $server->push($frame->fd, "Hallo, je stuurde: {$frame->data}");

    // Broadcastvoorbeeld (verbindingen bijhouden of doorlopen)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Niet terugsturen naar afzender
    //         $server->push($fd, "Gebruiker {$frame->fd} zegt: {$frame->data}");
    //     }
    // }
});

// Registreer 'close' event
// Wordt uitgevoerd als een client de verbinding sluit
$server->on("close", function ($ser, $fd) {
    echo "verbinding gesloten: {$fd}\n";
});

// Start de server
$server->start();

Dit script maakt een Swoole WebSocket-server op poort 9502 met callbacks voor de belangrijkste gebeurtenissen: start, open, message, en close. Berichten die via message binnenkomen worden teruggestuurd naar de verzender, voorafgegaan door een prefix.

Stap 2: Start de WebSocket-server

Ga met de terminal naar de map waar websocket_server.php staat en start het script met de juiste PHP-versie:

php websocket_server.php

Je ziet deze boodschap:

Swoole WebSocket server draait op ws://0.0.0.0:9502

Hiermee is je WebSocket-server gestart en luistert op poort 9502.

Stap 3: Verbind met de WebSocket-server

Er zijn meerdere testmogelijkheden—hieronder twee:

Methode A: Via browser developer tools

Moderne browsers hebben developer tools (F12) met een “Network” of “Console” tab. Gebruik deze om te testen:

1. Open een willekeurige webpagina, bijvoorbeeld about:blank.

2. Open developer tools en ga naar het “Console”-tabblad.

3. Plak deze JavaScript-code om verbinding te maken:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket verbinding geopend:", event);
     ws.send("Hello from Browser!"); // Stuurt een bericht zodra verbinding is gelegd
   };
   
   ws.onmessage = function(event) {
     console.log("Bericht van server:", event.data); // Bericht ontvangen
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket fout:", event); // Foutmelding indien aanwezig
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket verbinding gesloten:", event); // Verbinding gesloten
   };
   
   // Je kunt op elk moment ws.send("je bericht") gebruiken of ws.close() om af te sluiten

4. Na het uitvoeren van de code zie je de resultaten in de browser en de terminal van de server.

Methode B: Met de wscat CLI-tool

wscat is een eenvoudige WebSocket-client voor de terminal (Node.js vereist).

1. Installeer wscat: Als Node.js en npm nog niet geïnstalleerd zijn, eerst doen. Installeer dan wscat:

   npm install -g wscat

2. Maak verbinding: Voer het onderstaande commando uit in de terminal:

   wscat -c ws://localhost:9502

   Je ziet een > prompt zodra de verbinding is gelegd.

3. Test een bericht: Typ een bericht en druk op Enter;

   > Hello ServBay via wscat

   De server stuurt een antwoord terug, zichtbaar als:

   < Hallo, je stuurde: Hello ServBay via wscat

   Ook op de serverterminal zie je de log van het bericht.

Verbreek de wscat-verbinding met Ctrl + C.

Belangrijke aandachtspunten

• Poortconflict: Controleer of de Swoole-serverpoorten (9501, 9502) niet door andere processen worden gebruikt, anders start de server niet.
• PHP-versie: Gebruik bij het uitvoeren van scripts altijd de PHP-versie waarin Swoole is geactiveerd. Controleer met php -v welke versie actief is—ServBay heeft een handige tool voor PHP-switching.
• Extensie actief? Als starten niet lukt, controleer dan opnieuw of Swoole actief is voor jouw PHP-versie en of ServBay/PHP is herstart.
• Resident procesbeheer: Swoole-servers draaien als permanente processen. In productie heb je tools als Supervisor, Systemd of pm2 nodig voor bewaking/herstart. In ServBay lokaal is handmatig starten via de terminal meestal voldoende.

Samenvatting

Met ServBay activeer en gebruik je Swoole eenvoudig in je lokale ontwikkelomgeving, en bouw je snel high-performance PHP-applicaties—klassieke HTTP-diensten en moderne real-time WebSocket-toepassingen. De combinatie van de krachtige Swoole-extensie en de praktische ServBay-omgeving opent nieuwe mogelijkheden voor PHP-ontwikkelaars en helpt je efficiënter en robuuster te programmeren. Ga direct aan de slag met Swoole in ServBay!