Tworzenie i uruchamianie projektu Webman w ServBay

Czym jest Webman?

Webman to wydajny asynchroniczny framework PHP oparty na Workermanie, zaprojektowany specjalnie do budowania aplikacji webowych o wysokiej wydajności i dużej liczbie jednoczesnych połączeń. W przeciwieństwie do tradycyjnych, synchronicznych frameworków blokujących, Webman stosuje model napędzany zdarzeniami i asynchroniczny, nieblokujący I/O, co pozwala mu doskonale obsługiwać mnóstwo równoczesnych żądań. Webman zapewnia prosty interfejs API oraz elastyczny system rozszerzeń, co sprawia, że świetnie nadaje się do budowy aplikacji w czasie rzeczywistym, usług API, mikroserwisów i wielu innych.

Kluczowe cechy i zalety Webmana

• Wysoka wydajność: Bazuje na Workerman, wykorzystując mechanizmy zdarzeń i nieblokujące asynchroniczne I/O; obsługuje ogromną liczbę połączeń, osiągając wyższą przepustowość od tradycyjnych frameworków synchronicznych.
• Łatwość użycia: Prosty i intuicyjny API oraz bogata funkcjonalność — pozwala błyskawicznie zacząć budowę aplikacji.
• Wielo-protokółowość: Wbudowana obsługa popularnych protokołów aplikacyjnych, m.in. HTTP, WebSocket, co ułatwia budowę różnych typów serwisów.
• Elastyczne rozszerzenia: Łatwe rozszerzanie funkcjonalności przez pakiety Composer, wtyczki i mechanizmy middleware.
• Niskie zużycie zasobów: W odróżnieniu od klasycznego modelu serwera WWW + PHP-FPM, Webman działa w pamięci jako aplikacja rezydująca, wymagając mniejszych zasobów.
• Silna społeczność: Aktywne forum deweloperów oraz bogata dokumentacja.

Webman pozwala szybko budować wydajne i niezawodne aplikacje webowe i API, szczególnie tam, gdzie liczy się obsługa wielu równoczesnych połączeń i niskie opóźnienia.

Tworzenie i uruchamianie prostego projektu Webman w ServBay

Ten poradnik krok po kroku pokazuje, jak w lokalnym środowisku ServBay stworzyć i uruchomić prostą aplikację webową z wykorzystaniem Webmana. Wyjaśniamy, jak zainstalować Webmana, zbudować podstawowe trasy i kontrolery, a także jak zintegrować serwisy bazodanowe (MySQL, PostgreSQL) i cache (Redis, Memcached) dostępne w ServBay.

TIP

ServBay zaleca przechowywanie wszystkich lokalnych projektów WWW w katalogu /Applications/ServBay/www, co umożliwia łatwe zarządzanie przez ServBay, np. konfigurację stron lokalnych („hostów”).

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

1. Masz zainstalowany ServBay: ServBay jest poprawnie zainstalowany na Twoim macOS. To kompletne środowisko deweloperskie zawierające PHP, Composer, MySQL, PostgreSQL, Redis, Memcached i wszystkie pakiety wymagane w tym przewodniku.
2. Włączono niezbędne pakiety: Przez panel kontrolny ServBay upewnij się, że są zainstalowane i działają:
   • wybrana wersja PHP (zalecana najnowsza, np. PHP 8.x)
   • Composer (wbudowany)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Sprawdź, czy Twoja wersja PHP ma włączone wymagane rozszerzenia: memcached, redis, pdo_mysql, pdo_pgsql itp. ServBay domyślnie aktywuje niezbędne rozszerzenia — stan możesz sprawdzić w konfiguracji PHP w ServBay.
3. Korzystasz z Terminala: Potrafisz pracować z aplikacją Terminal w macOS.

Instalacja Webman

1. Sprawdź dostępność Composera

   ServBay posiada wbudowany Composer, skonfigurowany do uruchamiania w Terminalu. Sprawdź wersję poleceniem:

   composer --version

   Jeżeli pojawi się numer wersji Composera — wszystko gotowe.

2. Przejdź do katalogu stron ServBay

   Otwórz Terminal i wejdź do domyślnego katalogu projektów www:

   cd /Applications/ServBay/www

3. Utwórz projekt Webman za pomocą Composera

   Skorzystaj z polecenia create-project, by zainstalować Webmana w katalogu servbay-webman-app:

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

   Composer pobierze Webmana i wymagane biblioteki do tego katalogu.

4. Wejdź do nowego katalogu projektu

   Po zakończeniu instalacji przejdź do katalogu projektu:

   cd servbay-webman-app

5. Zainstaluj wymagane komponenty

   W celu demonstracji obsługi bazy danych i cache doinstaluj pakiety Composer: ORM, klienta Redis, paginację, eventy oraz narzędzie do debugowania. Flaga -W (--with-dependencies) zapewnia kompatybilność przy rozwiązywaniu zależności.

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

   To polecenie zainstaluje: ORM do baz danych, klienta Redis, narzędzia do paginacji i eventów oraz VarDumpera do debugowania.

Tworzenie bazy danych i tabel

Aby przykłady działały, stwórz w ServBay bazę danych webman_app i tabelę users zarówno dla MySQL, jak i PostgreSQL. Domyślne hasło dla użytkownika root to password.

Możesz użyć narzędzi takich jak phpMyAdmin lub pgAdmin (dostęp poprzez panel ServBay) albo wykonać polecenia SQL w terminalu.

1. Tworzenie bazy danych webman_app

   • MySQL:

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

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Tworzenie tabeli users w bazie 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; -- Połącz się z utworzoną bazą
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Pisanie kodu aplikacji webowej

Dodamy teraz podstawowe trasy, kontrolery oraz logikę współpracy z bazą i pamięciami cache.

1. Konfiguracja tras (routing)

   Edytuj plik config/route.php, dodając poniższy kod:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Definiuje trasę główną, kierującą do metody index w IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Trasy obsługujące cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Trasy obsługujące bazę danych
   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']);
   
   // Dodaj kolejne trasy w razie potrzeby...

2. Tworzenie plików kontrolerów

   W katalogu app/controller utwórz pliki: IndexController.php, CacheController.php oraz DatabaseController.php i dodaj do nich poniższy kod.

   • app/controller/IndexController.php: Obsługa żądań do ścieżki głównej.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Import klasy Response
     
     class IndexController
     {
         /**
          * Przykładowa metoda obsługująca żądanie do ścieżki głównej
          * @param Request $request Aktualny obiekt żądania
          * @return Response Zwraca obiekt Response
          */
         public function index(Request $request): Response // Jasno określony typ zwrotny
         {
             // Zwraca prostą odpowiedź tekstową
             return response('Hello ServBay & Webman!'); // Zaktualizowane powitanie
         }
     }

   • app/controller/CacheController.php: Przykład użycia Memcached i Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Import klasy Memcached
     use support\Redis; // Import fasady Redis z Webman
     
     class CacheController
     {
         /**
          * Przykład użycia Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Połączenie z serwerem Memcached; domyślnie ServBay: 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Ustawienie klucza cache na 60 sekund
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Nowy klucz i wartość
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Pobranie wartości cache
             $value = $memcached->get('servbay_key'); // Aktualny klucz
     
             // Zwraca pobraną wartość lub komunikat o braku
             return response($value ?: 'Memcached key not found or expired'); // Dodano komunikat o błędzie
         }
     
         /**
          * Przykład użycia Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Zapis do cache przez Redis z użyciem fasady Webman
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Nowy klucz i wartość
     
             // Odczyt z cache
             $value = Redis::get('servbay_redis_key'); // Aktualny klucz
     
             // Zwraca pobraną wartość lub komunikat o braku
             return response($value ?: 'Redis key not found'); // Dodano komunikat o błędzie
         }
     }

   • app/controller/DatabaseController.php: Pokazuje obsługę MySQL i PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Import fasady Db z Webman
     
     class DatabaseController
     {
         /**
          * Dodaje użytkownika do bazy MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Dodanie rekordu do MySQL
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Przykładowe dane
                     'email' => '[email protected]', // Przykładowy email
                     'created_at' => date('Y-m-d H:i:s') // Data utworzenia
                 ]);
                 return response('User added to MySQL'); // Komunikat sukcesu
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Obsługa błędów
             }
         }
     
         /**
          * Pobiera listę użytkowników z MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Pobranie wszystkich rekordów użytkowników z bazy MySQL
                 $users = Db::connection('mysql')->table('users')->get();
                 // Zwraca listę użytkowników w formacie JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type -> application/json
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Obsługa błędów
             }
         }
     
         /**
          * Dodaje użytkownika do bazy PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Dodanie rekordu do PostgreSQL
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Przykładowe dane
                     'email' => '[email protected]', // Przykładowy email
                     'created_at' => date('Y-m-d H:i:s') // Data utworzenia
                 ]);
                 return response('User added to PostgreSQL'); // Komunikat sukcesu
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Obsługa błędów
              }
         }
     
         /**
          * Pobiera listę użytkowników z PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Pobranie wszystkich rekordów użytkowników z PostgreSQL
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Zwraca listę użytkowników w formacie JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type -> application/json
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Obsługa błędów
              }
         }
     }

3. Konfiguracja połączeń z bazą

   Edytuj plik config/database.php i skonfiguruj dane dostępowe dla MySQL oraz PostgreSQL. Domyślny adres hosta: 127.0.0.1, porty: MySQL - 3306, PostgreSQL - 5432, login: root, hasło: password.

   <?php
   /**
    * Konfiguracja baz danych
    */
   return [
       // Domyślne połączenie
       'default' => 'mysql',
   
       // Lista dostępnych połączeń
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Domyślny host i port MySQL w ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nazwa bazy utworzona wcześniej
               'database'  => 'webman_app',
               // Domyślny użytkownik MySQL ServBay
               'username'  => 'root',
               // Domyślne hasło
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Domyślny host i port PostgreSQL w ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nazwa bazy utworzona wcześniej
               'database' => 'webman_app',
                // Domyślny użytkownik PostgreSQL ServBay
               'username' => 'root',
                // Domyślne hasło
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // Możesz także wybrać require, verify-ca, verify-full
           ],
           // Dodaj kolejne połączenia w razie potrzeby...
       ],
   ];

   Ważna uwaga: W środowisku produkcyjnym zmień domyślne hasło bazy danych i nie umieszczaj w kodzie danych wrażliwych.

Uruchamianie projektu Webman

Projekt Webman uruchamia się poleceniem start.php, które startuje procesy Workerman. To różni się od tradycyjnego modelu Nginx/Apache + PHP-FPM — Webman działa jako aplikacja rezydująca w pamięci.

W katalogu głównym projektu (/Applications/ServBay/www/servbay-webman-app) uruchom:

php start.php start

Po uruchomieniu zobaczysz komunikaty startowe Webmana — domyślnie nasłuchuje na 127.0.0.1:8787 na żądania HTTP.

• Uwaga: Polecenie php odwołuje się do PHP dostarczanego przez ServBay. ServBay ustawia zmienne środowiskowe, umożliwiając korzystanie z własnych instalacji PHP w Terminalu.
• Aby uruchomić Webmana w tle, dodaj -d: php start.php start -d.
• Aby zatrzymać serwis: php start.php stop.
• Aby zrestartować serwis: php start.php restart.
• Aby wykonać „łagodny” restart (bez przerywania trwających zapytań): php start.php reload.

Testowanie projektu

Gdy Webman działa i nasłuchuje na 127.0.0.1:8787, możesz wejść w przeglądarce na poniższe adresy:

• http://localhost:8787/ — pojawi się tekst Hello ServBay & Webman!
• http://localhost:8787/memcached — pojawi się tekst Hello Memcached from ServBay!, potwierdzając poprawną współpracę Webman z Memcached w ServBay.
• http://localhost:8787/redis — tekst Hello Redis from ServBay!, potwierdzający połączenie z Redis.
• http://localhost:8787/mysql-add — tekst User added to MySQL; wstawia rekord do tabeli users w bazie MySQL.
• http://localhost:8787/mysql — lista użytkowników z bazy MySQL w formacie JSON.
• http://localhost:8787/pgsql-add — tekst User added to PostgreSQL; wstawia rekord do tabeli users w PostgreSQL.
• http://localhost:8787/pgsql — lista użytkowników z PostgreSQL w formacie JSON.

Jeśli wystąpią problemy, sprawdź komunikaty z konsoli uruchomieniowej Webmana, ewentualne błędy oraz czy usługi MySQL, PostgreSQL, Redis, Memcached są aktywne, a odpowiednie rozszerzenia PHP włączone.

Najczęstsze pytania (FAQ)

• Q: Polecenie php start.php start nie działa?
  • A: Sprawdź, czy na pewno jesteś w katalogu servbay-webman-app. Upewnij się też, że ServBay ustawił PHP w Twoim PATH (domyślnie tak się dzieje).
• Q: localhost:8787 nie odpowiada?
  • A: Sprawdź, czy nie pojawiają się błędy przy php start.php start w terminalu. Upewnij się, że port 8787 nie jest zajęty przez inną aplikację. W razie potrzeby możesz zmienić port w pliku konfiguracyjnym Webman (config/server.php).
• Q: Brak połączenia z bazą danych?
  • A: Upewnij się, że pakiety MySQL i PostgreSQL są uruchomione. Sprawdź konfigurację w config/database.php (host, port, baza, login, hasło) oraz czy baza oraz tabela users istnieją.
• Q: Brak połączenia z Memcached lub Redis?
  • A: Upewnij się, że pakiety Memcached i Redis są aktywne w ServBay. Sprawdź adresy i porty w app/controller/CacheController.php (127.0.0.1:11211 dla Memcached, 127.0.0.1:6379 dla Redis). Sprawdź, czy PHP ma aktywne rozszerzenia memcached i redis.

Podsumowanie

Wykonując powyższe kroki stworzyłeś, skonfigurowałeś i uruchomiłeś podstawowy projekt Webman w lokalnym środowisku ServBay. Nauczyłeś się korzystać z pakietów ServBay do błyskawicznej konfiguracji środowiska PHP/Webman, ze wsparciem baz danych i cache. Połączenie wysokiej wydajności Webmana i wygody ServBay to idealne rozwiązanie dla rozwoju nowoczesnych, asynchronicznych aplikacji PHP. Ten przewodnik pomoże Ci w pełni wykorzystać potencjał ServBay oraz Webman do budowy doskonałych aplikacji webowych.