Ein Webman-Projekt in ServBay erstellen und ausführen

Was ist Webman?

Webman ist ein hochperformantes, asynchrones PHP Web-Framework, das auf Workerman basiert und speziell für den Bau von Webanwendungen mit hoher Parallelität und Performance entwickelt wurde. Im Gegensatz zu klassischen, synchron-blockierenden Frameworks nutzt Webman ein eventbasiertes und asynchrones, nicht-blockierendes I/O-Modell, was ihm ermöglicht, große Mengen gleichzeitiger Anfragen effizient zu bearbeiten. Das Framework bietet eine einfach bedienbare API und flexible Erweiterungsmöglichkeiten – ideal für die Entwicklung von Echtzeitanwendungen, API-Services, Microservices und mehr.

Hauptmerkmale und Vorteile von Webman

• Hochleistung: Basierend auf Workerman, verwendet Webman ein Event-Driven, asynchrones I/O und kann enorme Mengen an gleichzeitigen Verbindungen bedienen. Durchsatz und Effizienz sind klassischen, synchronen Frameworks deutlich überlegen.
• Einfach zu benutzen: Die intuitive API und umfassende Funktionalität ermöglichen einen schnellen Einstieg und effiziente Entwicklung.
• Unterstützung mehrerer Protokolle: HTTP, WebSocket und weitere Anwendungsprotokolle sind nativ unterstützt – ideal, um verschiedenste Services zu bauen.
• Flexible Erweiterbarkeit: Einfache Möglichkeit, Funktionen über Composer-Pakete, Plugins und Middleware zu erweitern.
• Geringer Ressourcenverbrauch: Da Webman als dauerhaft laufende Anwendung im Speicher agiert, ist der Verbrauch im Vergleich zu traditionellen Webservern + PHP-FPM niedriger.
• Starke Community: Eine aktive Entwicklergemeinschaft und umfangreiche Dokumentation stehen zur Verfügung.

Webman unterstützt Entwickler dabei, schnell und zuverlässig Webanwendungen und API-Services zu erstellen, insbesondere in Szenarien mit hohen Anforderungen an Parallelität und eine geringe Latenz.

Ein einfaches Webman-Projekt mit ServBay erstellen und ausführen

Diese Anleitung zeigt Ihnen Schritt für Schritt, wie Sie mit Webman innerhalb der lokalen ServBay-Entwicklungsumgebung ein simples Webprojekt realisieren. Sie lernen die Installation von Webman, das Schreiben grundlegender Routing- und Controller-Logik sowie die Integration von Datenbanken (MySQL, PostgreSQL) und Cache-Systemen (Redis, Memcached), die ServBay bereitstellt.

TIP

ServBay empfiehlt, alle lokalen Website-Projekte im Verzeichnis /Applications/ServBay/www abzulegen. So wird eine zentrale Verwaltung, etwa der Konfiguration lokaler Sites (früher „Hosts“ genannt), erleichtert.

Voraussetzungen

Bevor Sie starten, stellen Sie sicher, dass folgende Punkte erfüllt sind:

1. ServBay installiert: ServBay ist erfolgreich auf Ihrem macOS-System installiert. ServBay bietet eine Komplettlösung für die lokale Entwicklung inklusive PHP, Composer, MySQL, PostgreSQL, Redis, Memcached und mehr – alles, was Sie benötigen.
2. Benötigte Pakete aktiviert: Kontrollieren Sie im ServBay-Panel, dass folgende Pakete installiert und aktiv sind:
   • Gewünschte PHP-Version (Empfehlung: möglichst aktuelle Version, z.B. PHP 8.x)
   • Composer (in ServBay enthalten)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Prüfen Sie, ob alle nötigen PHP-Extensions wie memcached, redis, pdo_mysql, pdo_pgsql für Ihre PHP-Version aktiviert sind. ServBay aktiviert diese oft standardmäßig; Kontrolle über die ServBay PHP-Konfiguration.
3. Terminalzugang: Sie sind mit dem Terminal von macOS und dessen Nutzung vertraut.

Installation von Webman

1. Composer-Verfügbarkeit prüfen

   ServBay kommt mit Composer vorinstalliert und ist auf direkte Nutzung im Terminal eingerichtet. Überprüfen Sie Composer mit folgendem Befehl:

   composer --version

   Die Ausgabe einer Composer-Versionsnummer zeigt, dass Composer einsatzbereit ist.

2. Wechseln Sie ins ServBay-Webverzeichnis

   Öffnen Sie das Terminal und navigieren Sie ins empfohlene Verzeichnis:

   cd /Applications/ServBay/www

3. Webman-Projekt mit Composer anlegen

   Mit dem Composer-Befehl create-project installieren Sie Webman in ein neues Verzeichnis. Der Projektname: servbay-webman-app:

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

   Composer lädt Webman und alle Kernabhängigkeiten ins Verzeichnis servbay-webman-app.

4. Ins Projektverzeichnis wechseln

   Nach der Installation:

   cd servbay-webman-app

5. Notwendige Komponenten installieren

   Um Datenbank- und Cache-Funktionalitäten zu nutzen, installieren Sie zusätzliche Composer-Pakete, z.B. illuminate/database (Laravel-Komponente), illuminate/redis und weitere. Das -W-Flag (--with-dependencies) löst eventuelle Kompatibilitätsprobleme direkt bei der Installation:

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

   So erhalten Sie ORM, Redis-Client, Pagination, Event-Dispatcher sowie ein Debugging-Tool.

Datenbank und Tabelle anlegen

Damit die Beispielcodes funktionieren, benötigen Sie in ServBay jeweils eine Datenbank und die Tabelle users in MySQL und PostgreSQL. Das Standard-Passwort für den root-Benutzer in ServBay ist password.

Nutzen Sie für die folgenden SQLs entweder das ServBay-Panel (phpMyAdmin / pgAdmin) oder das Terminal.

1. Datenbank webman_app anlegen

   • MySQL:

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

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Tabelle users in der Datenbank erstellen

   • 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; -- Mit der angelegten Datenbank verbinden
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Webprojekt-Code schreiben

Jetzt ergänzen Sie den Code für Routing, Controller und Datenbank-/Cache-Interaktionen.

1. Routen konfigurieren

   Bearbeiten Sie die Datei config/route.php im Projekt-Root und ergänzen Sie die folgende Routing-Konfiguration:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Root-Routen: mapped auf IndexController->index
   Route::any('/', [IndexController::class, 'index']);
   
   // Cache-Routen
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Datenbank-Routen
   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']);
   
   // Weitere Routen können hier ergänzt werden...

2. Controller-Files erstellen

   Legen Sie im Verzeichnis app/controller die Files IndexController.php, CacheController.php und DatabaseController.php an und ergänzen Sie den folgenden Beispiel-Code:

   • app/controller/IndexController.php: Verarbeitung der Root-Anfragen.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Response-Klasse verwenden
     
     class IndexController
     {
         /**
          * Beispiel-Methode für die Root-Anfrage
          * @param Request $request Die aktuelle Anfrage
          * @return Response Gibt eine Response zurück
          */
         public function index(Request $request): Response // Klare Rückgabetypen
         {
             // Rückgabe einer einfachen Text-Antwort
             return response('Hello ServBay & Webman!'); // Begrüßungstext aktualisiert
         }
     }

   • app/controller/CacheController.php: Demo für Memcached und Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Memcached-Klasse verwenden
     use support\Redis; // Redis-Facade von Webman verwenden
     
     class CacheController
     {
         /**
          * Memcached-Demo
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Verbindung zu Memcached auf 127.0.0.1:11211 (ServBay-Default)
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Cache-Item setzen, Gültigkeit 60 Sek.
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Key & Value
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Cache-Item abrufen
             $value = $memcached->get('servbay_key'); // Key
     
             // Rückgabe des Werts
             return response($value ?: 'Memcached key not found or expired'); // Fehlermeldung bei Fehlschlag
         }
     
         /**
          * Redis-Demo
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Redis-Facade über Webman: Set Cache
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Key & Value
     
             // Redis-Facade über Webman: Get Cache
             $value = Redis::get('servbay_redis_key'); // Key
     
             // Rückgabe des Werts
             return response($value ?: 'Redis key not found'); // Fehlermeldung bei Fehlschlag
         }
     }

   • app/controller/DatabaseController.php: Demo für MySQL und PostgreSQL:

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Webman-Db-Facade verwenden
     
     class DatabaseController
     {
         /**
          * Benutzer zu MySQL hinzufügen
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Mit Db-Facade zur 'mysql'-DB verbinden und Eintrag zufügen
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Musterdaten
                     'email' => 'mysql_demo@servbay.test', // Musteremail
                     'created_at' => date('Y-m-d H:i:s') // Erstellungszeit
                 ]);
                 return response('User added to MySQL'); // Erfolgsmeldung
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Fehlerbehandlung
             }
         }
     
         /**
          * Benutzerliste aus MySQL abfragen
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Alle Benutzer aus 'mysql'-DB holen
                 $users = Db::connection('mysql')->table('users')->get();
                 // Rückgabe als JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type explizit
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Fehlerbehandlung
             }
         }
     
         /**
          * Benutzer zu PostgreSQL hinzufügen
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Mit Db-Facade zur 'pgsql'-DB verbinden und Eintrag zufügen
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Musterdaten
                     'email' => 'pgsql_demo@servbay.test', // Musteremail
                     'created_at' => date('Y-m-d H:i:s') // Erstellungszeit
                 ]);
                 return response('User added to PostgreSQL'); // Erfolgsmeldung
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Fehlerbehandlung
              }
         }
     
         /**
          * Benutzerliste aus PostgreSQL abfragen
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Alle Benutzer aus 'pgsql'-DB holen
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Rückgabe als JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type explizit
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Fehlerbehandlung
              }
         }
     }

3. Datenbankverbindung konfigurieren

   Bearbeiten Sie die Datei config/database.php im Projektstamm und passen Sie Host, Port und Zugangsdaten für MySQL und PostgreSQL entsprechend ServBay an. Standardmäßig ist der Datenbank-Host 127.0.0.1, die Ports sind 3306 (MySQL) und 5432 (PostgreSQL); Nutzername root, Passwort password.

   <?php
   /**
    * Datenbank-Konfiguration
    */
   return [
       // Standard-Datenbank-Verbindung
       'default' => 'mysql',
   
       // Verbindungsdatenbanken
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Standard MySQL Host und Port (ServBay)
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Name der angelegten Datenbank
               'database'  => 'webman_app',
               // Standard MySQL-Nutzer (ServBay)
               'username'  => 'root',
               // Standard-Passwort (ServBay)
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Standard PostgreSQL Host und Port (ServBay)
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Name der angelegten Datenbank
               'database' => 'webman_app',
                // Standard PostgreSQL-Nutzer (ServBay)
               'username' => 'root',
                // Standard-Passwort (ServBay)
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // alternativ: require, verify-ca, verify-full
           ],
           // Weitere Datenbank-Verbindungen können hier ergänzt werden...
       ],
   ];

   Wichtiger Hinweis: Im produktiven Einsatz sollten Sie das Standarddatenbankpasswort unbedingt ändern und sensible Informationen nie direkt im Code hinterlegen!

Webman-Projekt starten

Webman-Projekte werden gewöhnlich mit einem eigenen start.php-Skript über den Workerman-Prozess gestartet. Dies unterscheidet sich vom klassischen Betrieb über Nginx/Apache + PHP-FPM: Webman läuft als asynchrone Applikation dauerhaft im Speicher.

Zum Starten im Projektverzeichnis (/Applications/ServBay/www/servbay-webman-app):

php start.php start

Nach Ausführung sehen Sie eine Webman-Startmeldung; standardmäßig lauscht Webman auf HTTP-Anfragen unter 127.0.0.1:8787.

• Hinweis: Das verwendete php stammt aus der ServBay-Installation. ServBay richtet die Umgebungsvariable PATH so ein, dass Sie PHP direkt und ohne separate Konfiguration nutzen können.
• Für den Hintergrundbetrieb nutzen Sie das -d-Flag: php start.php start -d.
• Webman beenden: php start.php stop.
• Webman neustarten: php start.php restart.
• Sanft (ohne unterbrochene Requests) neustarten: php start.php reload.

Projekt testen

Nach erfolgreichem Start und sobald Webman auf 127.0.0.1:8787 hört, können Sie die folgenden URLs im Browser testen:

• http://localhost:8787/: Zeigt Hello ServBay & Webman! auf der Seite.
• http://localhost:8787/memcached: Zeigt Hello Memcached from ServBay! – die Verbindung zu Memcached in ServBay funktioniert.
• http://localhost:8787/redis: Zeigt Hello Redis from ServBay! – die Verbindung zu Redis in ServBay funktioniert.
• http://localhost:8787/mysql-add: Zeigt User added to MySQL – ein Eintrag wird in die MySQL-Tabelle users eingefügt.
• http://localhost:8787/mysql: Zeigt die Benutzerliste der MySQL-DB im JSON-Format.
• http://localhost:8787/pgsql-add: Zeigt User added to PostgreSQL – ein Eintrag wird in die PostgreSQL-Tabelle users eingefügt.
• http://localhost:8787/pgsql: Zeigt die Benutzerliste der PostgreSQL-DB im JSON-Format.

Sollten Probleme auftreten (z.B. kein Zugriff auf die URLs), kontrollieren Sie die Webman-Konsolenausgabe auf Fehlermeldungen und prüfen Sie, ob ServBay die Pakete MySQL, PostgreSQL, Redis, Memcached gestartet und alle PHP-Extensions aktiviert hat.

FAQ – Häufige Fragen und Probleme

• Q: Der Befehl php start.php start wird nicht gefunden?
  • A: Stellen Sie sicher, dass Sie mit cd in das Projektverzeichnis servbay-webman-app gewechselt haben. Prüfen Sie zudem, ob die ServBay-PHP-Installation zur PATH-Variable hinzugefügt wurde (ServBay erledigt dies normalerweise automatisch).
• Q: Zugriff auf localhost:8787 schlägt fehl?
  • A: Kontrollieren Sie die Konsole auf Fehlermeldungen beim Start mit php start.php start. Überprüfen Sie, ob Port 8787 frei ist. Der Port ist im Webman-Konfigurationsfile (z.B. config/server.php) änderbar.
• Q: Kann keine Verbindung zur Datenbank herstellen?
  • A: Prüfen Sie, ob MySQL und PostgreSQL in ServBay laufen und ob die Zugangsdaten in config/database.php korrekt sind (host, port, datenbank, benutzer, passwort). Stellen Sie sicher, dass Sie die Datenbank webman_app sowie die Tabelle users angelegt haben.
• Q: Verbindung zu Memcached oder Redis fehlschlägt?
  • A: Kontrollieren Sie, ob Memcached und Redis in ServBay laufen und ob die konfigurierten Adressen und Ports (127.0.0.1:11211 für Memcached bzw. 127.0.0.1:6379 für Redis) stimmen. Prüfen Sie, ob die Extensions memcached und redis in Ihrer PHP-Version aktiviert sind.

Fazit

Mit dieser Anleitung haben Sie erfolgreich ein Webman-Basisprojekt in Ihrer lokalen ServBay-Umgebung angelegt, konfiguriert und gestartet. Sie haben gelernt, wie ServBay Ihr Setup beschleunigt und welche Vorteile Webman hinsichtlich Performance und asynchroner Verarbeitung bietet. Dank integrierter Datenbank- und Cache-Lösungen sowie dem schlanken Framework profitieren Sie von einem schnellen und flexiblen Entwicklungsprozess für moderne PHP-Anwendungen. Wir wünschen Ihnen viel Erfolg beim Bau Ihrer Webprojekte mit ServBay und Webman!