Een Webman-project aanmaken en draaien in ServBay

Wat is Webman?

Webman is een krachtig, op Workerman gebaseerd asynchroon PHP-webframework, speciaal ontwikkeld voor het bouwen van zeer concurrerende en prestatiegerichte webapplicaties. In tegenstelling tot traditionele, blokkerende frameworks, gebruikt Webman een event-driven en asynchroon non-blocking I/O-model, waardoor het uitblinkt in het verwerken van grote aantallen gelijktijdige verzoeken. Webman biedt een intuïtieve API en een flexibele uitbreidingsstructuur, waardoor het uitstekend geschikt is voor realtime toepassingen, API-diensten, microservices en meer.

Belangrijkste kenmerken en voordelen van Webman

• Hoge prestaties: Gebouwd op Workerman en maakt gebruik van event-driven, asynchrone I/O. Kan enorme aantallen gelijktijdige verbindingen aan, met een throughput die veel hoger ligt dan bij traditionele frameworks.
• Gebruiksvriendelijk: Een overzichtelijke, simpele API en tal van functies maken het gemakkelijk voor ontwikkelaars om snel aan de slag te gaan en apps te bouwen.
• Ondersteuning van meerdere protocollen: Ondersteunt standaard HTTP, WebSocket en andere veelgebruikte applicatieprotocollen – ideaal voor verschillende soorten services.
• Flexibel uit te breiden: Dankzij ondersteuning voor Composer-pakketten, plug-ins en middlewares kan het framework eenvoudig worden uitgebreid.
• Zuinig met systeembronnen: In vergelijking met het klassieke model van webserver + PHP-FPM werkt Webman als een resident-in-geheugen-toepassing met een veel lagere overhead.
• Sterke community: Een actieve gemeenschap van ontwikkelaars en uitgebreide documentatie dragen bij aan ondersteuning en groei.

Met Webman kun je snel webapplicaties en API-diensten bouwen die zowel schaalbaar als performant zijn – bijzonder geschikt voor scenario’s met hoge gelijktijdigheid en lage latency.

Een eenvoudig Webman-project aanmaken en uitvoeren in ServBay

In deze gids lees je stap-voor-stap hoe je in de ServBay lokale ontwikkelomgeving een Webman-webproject aanmaakt en draait. We demonstreren het installatieproces, basis routering en controlelogica, en hoe je de database (MySQL, PostgreSQL) en caching-diensten (Redis, Memcached) van ServBay integreert.

TIP

ServBay raadt aan om alle lokale websiteprojecten onder de map /Applications/ServBay/www op te slaan. Dit maakt het eenvoudig voor ServBay om sites centraal te beheren, zoals het configureren van lokale websites (voorheen bekend als “hosts”).

Vereisten

Voordat je begint, zorg dat je het volgende geregeld hebt:

1. Installeer ServBay: ServBay is succesvol geïnstalleerd op je macOS. ServBay biedt een complete lokale ontwikkelomgeving met PHP, Composer, MySQL, PostgreSQL, Redis, Memcached en alle andere vereiste tools.
2. Benodigde pakketten ingeschakeld: Open het ServBay-configuratiescherm en controleer of de volgende pakketten geïnstalleerd en actief zijn:
   • PHP-versie naar keuze (nieuwere versies zoals PHP 8.x aanbevolen)
   • Composer (is inbegrepen bij ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Controleer bovendien dat de noodzakelijke PHP-extensies zoals memcached, redis, pdo_mysql, pdo_pgsql zijn ingeschakeld. Deze zijn doorgaans standaard geactiveerd in ServBay, maar je kunt dit checken in het PHP-configuratiepaneel.
3. Toegang tot Terminal: Je kent de basis van het werken met Terminal in macOS.

Webman installeren

1. Controleer of Composer werkt

   ServBay wordt standaard geleverd met Composer, voorgeconfigureerd voor de terminal. Je controleert dit met:

   composer --version

   Indien een Composer-versie wordt getoond, ben je klaar om door te gaan.

2. Ga naar de website-directory van ServBay

   Open je terminal en navigeer naar de aanbevolen rootmap voor ServBay-websites:

   cd /Applications/ServBay/www

3. Maak het Webman-project aan met Composer

   Gebruik het Composer-commando create-project om het Webman-framework te installeren in bijvoorbeeld een map genaamd servbay-webman-app:

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

   Composer downloadt Webman en alle core-afhankelijkheden naar deze directory.

4. Navigeer naar de projectmap

   Na de installatie ga je naar je nieuwe projectmap:

   cd servbay-webman-app

5. Installeer benodigde aanvullende pakketten

   Om database- en caching-functionaliteiten te demonstreren, voeg je enkele Composer packages toe, zoals illuminate/database (Laravel’s database component), illuminate/redis, enz. Gebruik hierbij de -W (“with dependencies”)-optie voor compatibiliteit.

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

   Dit installeert de ORM, Redis-client, paginatie-extensie, event dispatcher en een hulpprogramma voor debugging.

Database en tabellen aanmaken

Voor de voorbeeldcode werkt, moeten we in MySQL en PostgreSQL geschikte databases en een users-tabel aanmaken binnen ServBay. Het standaard root-wachtwoord voor databases in ServBay is password.

Gebruik de databasebeheertools van ServBay (zoals phpMyAdmin of pgAdmin, te benaderen via het ServBay-configuratiescherm) of werk met de command-line voor de volgende SQL-statements.

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 users-tabel aan in webman_app

   • 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; -- verbinden met de zojuist 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 voegen we code toe om routes te definiëren, controllers te maken, en database- plus cachinglogica te implementeren.

1. Routes configureren

   Bewerk het bestand config/route.php in de projectroot en voeg de volgende code toe om de benodigde voorbeeldroutes te definiëren:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Definieer de root route, koppelt naar de index-methode van IndexController
   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-operaties
   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']);
   
   // Voeg hier extra routes toe indien gewenst...

2. Maak controllerbestanden aan

   Maak onder app/controller de bestanden IndexController.php, CacheController.php en DatabaseController.php aan. Voeg in elk het volgende in.

   • app/controller/IndexController.php: Afhandeling van root requests.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Importeer Response klasse
     
     class IndexController
     {
         /**
          * Voorbeeldmethode voor root requests
          * @param Request $request huidige verzoekobject
          * @return Response Response-object
          */
         public function index(Request $request): Response // Geeft type expliciet op
         {
             // Eenvoudige tekstuele respons retourneren
             return response('Hello ServBay & Webman!'); // Welkomsttekst geüpdatet
         }
     }

   • app/controller/CacheController.php: Voorbeeldgebruik van Memcached en Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Import Memcached klasse
     use support\Redis; // Importeer de Redis Facade die door Webman geleverd wordt
     
     class CacheController
     {
         /**
          * Voorbeeld van gebruik van Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Maak verbinding met Memcached-server, standaard draait ServBay op 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Stel een cache-item in, geldig voor 60 seconden
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Key en waarde aangepast
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Haal het cache-item op
             $value = $memcached->get('servbay_key'); // Key opgehaald
     
             // Retourneer de opgehaalde waarde
             return response($value ?: 'Memcached key not found or expired'); // Geeft melding als key niet bestaat
         }
     
         /**
          * Voorbeeld van gebruik van Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Zet een cache-item via de Redis Facade van Webman
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Key en waarde aangepast
     
             // Haal het item op via de Redis Facade van Webman
             $value = Redis::get('servbay_redis_key'); // Key ophalen
     
             // Retourneer de opgehaalde waarde
             return response($value ?: 'Redis key not found'); // Geeft melding als key niet bestaat
         }
     }

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

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Importeer Db Facade van Webman
     
     class DatabaseController
     {
         /**
          * Voeg gebruiker toe aan MySQL-database
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Verbind met 'mysql' via Db Facade en voeg een record toe
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Voorbeelddata aangepast
                     'email' => 'mysql_demo@servbay.test', // Voorbeelde-mailadres aangepast
                     'created_at' => date('Y-m-d H:i:s') // Toegevoegd veld
                 ]);
                 return response('User added to MySQL'); // Respons-tekst aangepast
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Foutafhandeling toegevoegd
             }
         }
     
         /**
          * Haal gebruikerslijst uit MySQL-database
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Haal alle gebruikers op door verbinding met 'mysql'
                 $users = Db::connection('mysql')->table('users')->get();
                 // Geef de gebruikerslijst in JSON-formaat terug
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type gezet
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Foutafhandeling
             }
         }
     
         /**
          * Voeg gebruiker toe aan PostgreSQL-database
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Verbind met 'pgsql' via Db Facade en voeg een record toe
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Voorbeelddata aangepast
                     'email' => 'pgsql_demo@servbay.test', // Voorbeelde-mailadres aangepast
                     'created_at' => date('Y-m-d H:i:s') // Toegevoegd veld
                 ]);
                 return response('User added to PostgreSQL'); // Respons-tekst aangepast
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Foutafhandeling
              }
         }
     
         /**
          * Haal gebruikerslijst uit PostgreSQL-database
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Haal alle gebruikers op door verbinding met 'pgsql'
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Geef de gebruikerslijst in JSON-formaat terug
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type gezet
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Foutafhandeling
              }
         }
     }

3. Databaseconnecties configureren

   Bewerk het bestand config/database.php in de root van je project en stel de connectie-instellingen voor MySQL en PostgreSQL als volgt in. Standaard zijn de database host 127.0.0.1, poorten 3306 (MySQL) en 5432 (PostgreSQL), met gebruiker root en wachtwoord password.

   <?php
   /**
    * Databaseconfiguratie
    */
   return [
       // Standaard verbindingsprofiel
       'default' => 'mysql',
   
       // Overzicht van de databaseverbindingen
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Standaard MySQL host en poort in ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Naam van de eerder aangemaakte database
               'database'  => 'webman_app',
               // Standaard gebruikersnaam
               'username'  => 'root',
               // Standaard wachtwoord
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Standaard PostgreSQL host en poort in ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
               // Naam van de eerder aangemaakte database
               'database' => 'webman_app',
               // Standaard gebruikersnaam
               'username' => 'root',
               // Standaard wachtwoord
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // Of 'require', 'verify-ca', 'verify-full'
           ],
           // Voeg hier naar wens meer databaseconnecties toe...
       ],
   ];

   Belangrijk: In een productieomgeving moet je altijd het standaard databasewachtwoord wijzigen en vermijden om gevoelige gegevens hardcoded te laten staan.

Het Webman-project draaien

Webman-projecten worden doorgaans opgestart via het bijgeleverde start.php-script, waardoor Workerman-processen gestart worden. Let op: In tegenstelling tot het klassieke Nginx/Apache + PHP-FPM-model draait Webman als een asynchrone resident-in-geheugen-applicatie.

Ga in de projectdirectory (/Applications/ServBay/www/servbay-webman-app) en start je Webman-project met:

php start.php start

Na uitvoering van dit commando krijg je op de terminal de startinformatie van Webman te zien. Standaard luistert het framework op HTTP-poort 127.0.0.1:8787.

• Let op: Het php-commando gebruikt automatisch de PHP-versie die door ServBay beschikbaar is gesteld. ServBay zet je terminalomgeving hierop in.
• Als je Webman als daemon (in de achtergrond) wil draaien, voeg -d toe: php start.php start -d.
• Om Webman te stoppen, gebruik: php start.php stop.
• Om Webman te herstarten: php start.php restart.
• Voor een zachte (graceful) herstart: php start.php reload.

Testen van het project

Na een succesvolle start—Webman luistert op 127.0.0.1:8787—kun je in je browser de volgende URL's aanroepen om functies te testen:

• http://localhost:8787/ – Je ziet de tekst Hello ServBay & Webman!.
• http://localhost:8787/memcached – De tekst Hello Memcached from ServBay! bevestigt dat Memcached werkt.
• http://localhost:8787/redis – De tekst Hello Redis from ServBay! toont correcte Redis-integratie.
• http://localhost:8787/mysql-add – Toont User added to MySQL en voegt een record toe in de MySQL users-tabel.
• http://localhost:8787/mysql – Geeft een JSON-uitvoer met alle gebruikers uit MySQL.
• http://localhost:8787/pgsql-add – Toont User added to PostgreSQL en voegt een record toe aan de PostgreSQL-tabel.
• http://localhost:8787/pgsql – Geeft een JSON-uitvoer met alle gebruikers uit PostgreSQL users.

Mocht je issues tegenkomen bij toegang tot deze URL's, bekijk dan de terminaloutput van Webman voor foutmeldingen. Controleer of MySQL, PostgreSQL, Redis en Memcached actief zijn in ServBay, en of de benodigde PHP-extensies zijn ingeschakeld.

Veelgestelde Vragen (FAQ)

• Vraag: php start.php start wordt niet gevonden?
  • Antwoord: Controleer of je in de correcte projectmap (servbay-webman-app) zit. Zorg er ook voor dat de door ServBay geïnstalleerde PHP gelijk correct in je PATH is gezet (ServBay regelt dit normaal automatisch).
• Vraag: Krijg een foutmelding bij toegang tot localhost:8787?
  • Antwoord: Controleer eventuele foutmeldingen in de terminal na het uitvoeren van php start.php start. Controleer of poort 8787 vrij is. Desgewenst pas je het poortnummer aan in bijvoorbeeld config/server.php.
• Vraag: Databaseverbinding mislukt?
  • Antwoord: Controleer of MySQL en PostgreSQL in ServBay draaien. Check de instellingen in config/database.php (host, poort, database, gebruikersnaam, wachtwoord). Zorg dat je de database webman_app en tabel users hebt aangemaakt.
• Vraag: Kan niet verbinden met Memcached of Redis?
  • Antwoord: Kijk of Memcached en Redis in ServBay lopen. Controleer adressen en poorten in app/controller/CacheController.php (127.0.0.1:11211 en 127.0.0.1:6379). Controleer of de extensies memcached en redis aanstaan voor je PHP-versie.

Samenvatting

Met deze stappen heb je in ServBay’s lokale ontwikkelomgeving met succes een basis Webman-project opgezet, geconfigureerd en gestart. Je hebt geleerd hoe je via ServBay snel je Webman-ontwikkelomgeving kunt opzetten en zowel database- als cachingmogelijkheden kunt integreren. De krachtige prestaties van Webman, aangevuld met het gemak van ServBay, bieden een stabiele basis voor het ontwikkelen van asynchrone PHP-applicaties. Hopelijk helpt deze handleiding je maximaal gebruik te maken van ServBay en Webman om uitstekende webprojecten te realiseren.