Een Webman-project aanmaken en uitvoeren in ServBay

Wat is Webman?

Webman is een high-performance PHP asynchroon webframework, gebouwd op Workerman en speciaal ontworpen voor het bouwen van hoogwaardige, uiterst performante webapplicaties met veel gelijktijdige connecties. In tegenstelling tot traditionele, synchrone en blokkerende frameworks, gebruikt Webman een event-driven en asynchrone non-blocking I/O-model, waardoor het uitblinkt bij de afhandeling van grote aantallen gelijktijdige verzoeken. Webman biedt een eenvoudige en toegankelijke API en een flexibel uitbreidingssysteem, ideaal voor het ontwikkelen van realtime applicaties, API-diensten, microservices en meer.

Belangrijkste kenmerken en voordelen van Webman

• Hoge prestaties: Gebouwd op Workerman, maakt gebruik van event-driven en asynchrone non-blocking I/O, kan enorme aantallen gelijktijdige connecties afhandelen en levert een aanzienlijk hogere throughput dan traditionele, synchrone frameworks.
• Gebruiksvriendelijk: Eenvoudige, intuïtieve API en uitgebreide functionaliteit maken het mogelijk voor ontwikkelaars om snel van start te gaan.
• Ondersteuning voor meerdere protocollen: Standaard ondersteuning voor HTTP, WebSocket en andere veelgebruikte application-layer protocollen, wat het bouwen van diverse diensten vergemakkelijkt.
• Flexibel uitbreidbaar: Uitbreiden van frameworkfunctionaliteit is eenvoudig via Composer packages, plugins en middleware.
• Lage resourceconsumptie: Vergeleken met traditionele webserver + PHP-FPM oplossingen draait Webman als een resident-geheugenapplicatie, waardoor de systeembelasting lager is.
• Sterke community-ondersteuning: Actieve ontwikkelaarscommunity en ruime documentatie beschikbaar.

Webman stelt ontwikkelaars in staat om snel webapplicaties en API-diensten te bouwen die hoog performant en goed schaalbaar zijn—uitermate geschikt voor scenario’s die veel gelijktijdige verbindingen en lage latentie vereisen.

Een simpel Webman-project aanmaken en uitvoeren met ServBay

Deze gids laat gedetailleerd zien hoe je in de ServBay lokaal ontwikkelomgeving een eenvoudig Webman project opzet en uitvoert. We doorlopen de installatie van Webman, het schrijven van basis routerings- en controllercode en het integreren van door ServBay geleverde database (MySQL, PostgreSQL) en cachingdiensten (Redis, Memcached).

TIP

ServBay raadt ontwikkelaars aan om alle lokale websiteprojecten op te slaan in de map /Applications/ServBay/www. Zo kun je eenvoudig al je sites centraal beheren, bijvoorbeeld bij het configureren van lokale websites (voorheen "host").

Vereisten

Zorg dat je de volgende voorbereidingen hebt getroffen voordat je begint:

1. Installeer ServBay: Je hebt ServBay succesvol geïnstalleerd op macOS. ServBay biedt een complete lokale ontwikkelomgeving, inclusief PHP, Composer, MySQL, PostgreSQL, Redis, Memcached en overige benodigde pakketten voor deze tutorial.
2. Activeer benodigde pakketten: Via het ServBay dashboard zorg je dat onderstaande pakketten zijn geïnstalleerd en actief:
   • De gewenste PHP-versie (aanbevolen: recente versie zoals PHP 8.x)
   • Composer (ingebouwd in ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Controleer dat je gekozen PHP-versie de nodige extensies zoals memcached, redis, pdo_mysql, pdo_pgsql ingeschakeld heeft. Meestal zijn deze standaard geactiveerd, te controleren via ServBays PHP-configuratie.
3. Terminaltoegang: Je bent vertrouwd met het gebruik van de Terminal op macOS.

Webman installeren

1. Controleer of Composer beschikbaar is

   ServBay wordt standaard geleverd met Composer, geconfigureerd voor direct gebruik in de terminal. Controleer dit door het volgende commando uit te voeren:

   composer --version

   Zie je het Composer versie-informatie verschijnen, dan is Composer klaar voor gebruik.

2. Ga naar de ServBay website directory

   Open de terminal en ga naar de aanbevolen website-rootmap:

   cd /Applications/ServBay/www

3. Maak een Webman-project aan via Composer

   Gebruik de Composer create-project opdracht om het Webman framework te installeren in een nieuwe map. We noemen het project servbay-webman-app:

   composer create-project workerman/webman servbay-webman-app

   Composer downloadt Webman en afhankelijkheden naar de map servbay-webman-app.

4. Ga naar het projectmap

   Na de installatie, ga naar de nieuw aangemaakte projectmap:

   cd servbay-webman-app

5. Installeer benodigde componenten

   Voor database- en cachingfunctionaliteit moeten we aanvullende Composer pakketten installeren. Webman maakt doorgaans gebruik van illuminate/database (van Laravel), illuminate/redis en meer. De -W parameter (--with-dependencies) zorgt voor het oplossen van afhankelijkheden:

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Hiermee worden de database ORM, Redis client, pagineringscomponent, eventdispatcher en VarDumper debugging-tool geïnstalleerd.

Een database en tabellen aanmaken

Voor het werken van de voorbeeldcode dien je de juiste database en users tabel aan te maken in ServBay’s MySQL en PostgreSQL databases. Het standaard wachtwoord van de root databasegebruiker is password.

Gebruik ServBay’s database-tools (zoals phpMyAdmin of pgAdmin, te benaderen via het controlepaneel) of voer onderstaande SQL-commando’s uit via de terminal.

1. Maak de database webman_app aan

   • MySQL:

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Maak de tabel users aan in de webman_app database

   • MySQL:

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL:

     \c webman_app; -- Verbind met de nieuw aangemaakte database
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Webprojectcode schrijven

Nu gaan we routes definiëren, controllers aanmaken, en de interactie met de database en cache implementeren.

1. Routes configureren

   Bewerk het bestand config/route.php in de hoofdmap van je project en voeg onderstaande code toe om de benodigde routes te definiëren:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Definieer root route, verwijst naar IndexController's index methode
   Route::any('/', [IndexController::class, 'index']);
   
   // Definieer routes voor caching
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Definieer routes voor database bewerkingen
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Hier kun je meer routes toevoegen ...

2. Controllerbestanden aanmaken

   Maak in de map app/controller de bestanden IndexController.php, CacheController.php en DatabaseController.php aan en voeg onderstaande code toe.

   • app/controller/IndexController.php: Handelt de root route af.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Importeer Response class
     
     class IndexController
     {
         /**
          * Voorbeeldmethode om root route te verwerken
          * @param Request $request Het huidige request object
          * @return Response Geeft een Response object terug
          */
         public function index(Request $request): Response // Duidelijke return type
         {
             // Geeft een simpele tekstuele reactie
             return response('Hello ServBay & Webman!'); // Aangepaste welkomstboodschap
         }
     }

   • app/controller/CacheController.php: Laat gebruik van Memcached en Redis zien.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Importeer Memcached class
     use support\Redis; // Importeer Webman’s Redis Facade
     
     class CacheController
     {
         /**
          * Toont het gebruik van Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Verbind met Memcached server, standaard ingesteld op 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Sla een cache item op, 60 seconden geldig
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Aangepaste key en value
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Haal het cache item op
             $value = $memcached->get('servbay_key'); // Aangepaste key
     
             // Retourneer de opgehaalde waarde
             return response($value ?: 'Memcached key not found or expired'); // Boodschap indien niet gevonden
         }
     
         /**
          * Toont het gebruik van Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Gebruik Webman’s Redis Facade om cache op te slaan
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Aangepaste key en value
     
             // Gebruik Webman’s Redis Facade om cache op te halen
             $value = Redis::get('servbay_redis_key'); // Aangepaste key
     
             // Retourneer de opgehaalde waarde
             return response($value ?: 'Redis key not found'); // Boodschap indien niet gevonden
         }
     }

   • app/controller/DatabaseController.php: Voorbeeld van MySQL en PostgreSQL databasebewerkingen.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Importeer Webman’s Db Facade
     
     class DatabaseController
     {
         /**
          * Voeg een gebruiker toe aan de MySQL database
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Verbind met 'mysql' database en voeg gegevens toe
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Voorbeelddata
                     'email' => 'mysql_demo@servbay.test', // Voorbeeld e-mailadres
                     'created_at' => date('Y-m-d H:i:s') // Toevoegen created_at
                 ]);
                 return response('User added to MySQL'); // Bevestigingsmelding
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Foutmelding
             }
         }
     
         /**
          * Haal gebruikerslijst op uit MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Verbind met 'mysql' database en haal alle gebruikers op
                 $users = Db::connection('mysql')->table('users')->get();
                 // Geeft lijst terug als JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Specificeer Content-Type
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Foutmelding
             }
         }
     
         /**
          * Voeg een gebruiker toe aan de PostgreSQL database
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Verbind met 'pgsql' database en voeg gegevens toe
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Voorbeelddata
                     'email' => 'pgsql_demo@servbay.test', // Voorbeeld e-mailadres
                     'created_at' => date('Y-m-d H:i:s') // Toevoegen created_at
                 ]);
                 return response('User added to PostgreSQL'); // Bevestigingsmelding
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Foutmelding
              }
         }
     
         /**
          * Haal gebruikerslijst op uit PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Verbind met 'pgsql' database en haal alle gebruikers op
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Geeft lijst terug als JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Specificeer Content-Type
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Foutmelding
              }
         }
     }

3. Databaseverbinding configureren

   Bewerk config/database.php in de hoofdmap van je project om MySQL en PostgreSQL verbindingen te configureren. ServBay’s standaard database host is 127.0.0.1, poort 3306 (MySQL) en 5432 (PostgreSQL). Het standaard root wachtwoord is password.

   <?php
   /**
    * Databaseconfiguratie
    */
   return [
       // Standaard gebruikte database connection
       'default' => 'mysql',
   
       // Databaseverbindingen
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // ServBay standaard MySQL host en poort
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Eerder aangemaakte databasenaam
               'database'  => 'webman_app',
               // ServBay standaard MySQL gebruikersnaam
               'username'  => 'root',
               // ServBay standaard MySQL wachtwoord
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // ServBay standaard PostgreSQL host en poort
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Eerder aangemaakte databasenaam
               'database' => 'webman_app',
                // ServBay standaard PostgreSQL gebruikersnaam
               'username' => 'root',
                // ServBay standaard PostgreSQL wachtwoord
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // Ook mogelijk: require, verify-ca, verify-full
           ],
           // Je kunt hier meer databaseconnecties toevoegen ...
       ],
   ];

   Belangrijk: Wijzig nooit het standaard databasewachtwoord in productieomgevingen en voorkom hardcoderen van gevoelige gegevens in de code.

Webman-project starten

Webman-projecten starten hun Workerman processen via het meegeleverde start.php script. Anders dan de traditionele Nginx/Apache + PHP-FPM aanpak, draait Webman als een asynchroon resident-geheugenprogramma.

Start het Webman-project in de directory (/Applications/ServBay/www/servbay-webman-app) met het volgende commando:

php start.php start

Na het uitvoeren van dit commando zie je de opstartinformatie van Webman. Standaard luistert Webman op HTTP-verzoeken via 127.0.0.1:8787.

• Let op: Het commando php is van ServBay, die automatisch de juiste PHP-versie in je terminalomgeving beschikbaar maakt.
• Gebruik -d voor background mode: php start.php start -d.
• Webman stoppen? Gebruik: php start.php stop.
• Herstarten? Gebruik: php start.php restart.
• Soepel herstarten (zonder actieve verzoeken te onderbreken): php start.php reload.

Het project testen

Als Webman draait en luistert op 127.0.0.1:8787, kun je de volgende URL’s in je browser gebruiken om de functies te testen:

• http://localhost:8787/: De pagina laat Hello ServBay & Webman! zien.
• http://localhost:8787/memcached: Je ziet Hello Memcached from ServBay!, het bewijs dat ServBay’s Memcached-service werkt via Webman.
• http://localhost:8787/redis: Je ziet Hello Redis from ServBay!, als je ServBay’s Redis-service via Webman werkt.
• http://localhost:8787/mysql-add: Je ziet User added to MySQL. Hiermee voeg je een record toe aan de users tabel van de MySQL database.
• http://localhost:8787/mysql: Je krijgt een JSON-lijst van gebruikers uit de MySQL-users tabel.
• http://localhost:8787/pgsql-add: Je ziet User added to PostgreSQL. Hiermee voeg je een gebruiker toe aan de PostgreSQL database.
• http://localhost:8787/pgsql: Je krijgt een JSON-lijst van gebruikers uit de PostgreSQL-users tabel.

Krijg je foutmeldingen bij deze URL’s, controleer dan de Webman-terminaluitvoer op errors, of check of ServBay’s MySQL, PostgreSQL, Redis, Memcached pakketten draaien en of de PHP-extensies geactiveerd zijn.

Veelgestelde vragen (FAQ)

• Q: Het commando php start.php start werkt niet?
  • A: Controleer of je met de terminal in de map servbay-webman-app zit en of ServBay’s PHP aan je PATH is toegevoegd (meestal automatisch geregeld).
• Q: Verbinding met localhost:8787 mislukt?
  • A: Check de terminaluitvoer van php start.php start op errors. Zorg dat poort 8787 vrij is; zo niet, pas de poortinstelling aan in bijvoorbeeld config/server.php.
• Q: Databaseverbinding werkt niet?
  • A: Controleer of MySQL en PostgreSQL draaien in ServBay. Controleer databasegegevens in config/database.php (host, poort, naam, gebruiker, wachtwoord) en dat je de database en tabel hebt aangemaakt.
• Q: Memcached of Redis-verbinding mislukt?
  • A: Check of Memcached en Redis actief zijn in ServBay. Controleer in app/controller/CacheController.php of de host en poort correct zijn (standaard 127.0.0.1:11211 en 127.0.0.1:6379). Zorg dat je PHP-versie memcached en redis extensies ondersteunt.

Samenvatting

Met bovenstaande stappen heb je succesvol een basis Webman-project opgezet, geconfigureerd en uitgevoerd in de lokale ServBay-ontwikkelomgeving. Je hebt geleerd hoe je ServBay’s alles-in-één oplossing gebruikt om snel een Webman ontwikkelomgeving op te zetten en hoe je database- en cachefuncties integreert. Dankzij Webmans hoge performance en ServBays gebruiksgemak beschik je nu over een stevige basis voor het ontwikkelen van asynchrone PHP-applicaties. Hopelijk helpt deze gids je om met ServBay en Webman uitstekende webapplicaties te bouwen!