Tworzenie i uruchamianie projektu PHPixie na macOS z użyciem ServBay

PHPixie to lekki i wydajny framework PHP stworzony z myślą o szybkim rozwijaniu aplikacji webowych. Opiera się na wzorcu projektowym HMVC (Hierarchical Model-View-Controller), oferuje przejrzystą strukturę kodu oraz efektywne przetwarzanie żądań. PHPixie zdobył popularność dzięki swojej prostocie, elastyczności i wysokiej wydajności.

Najważniejsze cechy i zalety PHPixie

Lekkość: Rdzeń frameworka PHPixie jest bardzo zwięzły, zawiera tylko niezbędne komponenty do budowy aplikacji, co przekłada się na szybkie uruchamianie.
Wysoka wydajność: Konstrukcja frameworka została zoptymalizowana pod kątem efektywności, umożliwia skuteczne obsługiwanie wielu jednoczesnych żądań – idealna do wymagających aplikacji.
Łatwość nauki: Czytelne i intuicyjne API oraz rozbudowana dokumentacja pozwalają szybko opanować jego obsługę nawet początkującym programistom.
Elastyczność: Luźna struktura i niski poziom sprzężenia umożliwia swobodny wybór oraz integrację zewnętrznych bibliotek i komponentów według potrzeb projektu.
Wsparcie aktywnej społeczności: Framework posiada zaangażowaną społeczność programistów i bogatą bazę rozszerzeń oraz materiałów pomocniczych.

PHPixie umożliwia szybkie tworzenie wysokowydajnych i solidnych aplikacji webowych – od małych projektów po rozbudowane systemy klasy enterprise.

Tworzenie i uruchamianie projektu PHPixie za pomocą ServBay

Ten przewodnik przeprowadzi Cię przez proces tworzenia oraz uruchamiania projektu PHPixie w lokalnym środowisku deweloperskim ServBay. Skorzystamy z wbudowanego PHP, menedżera zależności Composer oraz funkcji „Websites” do konfiguracji serwera WWW. Dzięki prostym krokom uzyskasz dostęp do swojej aplikacji lokalnie i zintegrujesz ją z bazą danych oraz cache.

Wymagania wstępne

ServBay jest zainstalowany i uruchomiony na macOS. ServBay zawiera PHP, Composer, różne bazy danych (MySQL, PostgreSQL, MongoDB, Redis itd.) oraz serwer WWW Caddy.
Podstawowa znajomość obsługi terminala.

Tworzenie projektu PHPixie

Zalecana lokalizacja projektu

ServBay rekomenduje, aby wszystkie lokalne projekty WWW były umieszczone w katalogu /Applications/ServBay/www. Ułatwia to zarządzanie oraz kontrolę dostępu.

Potwierdź instalację Composer: ServBay dostarcza Composer w standardzie – nie musisz instalować go osobno. Potwierdź wersję Composer, wpisując w terminalu composer --version.
Utwórz folder projektu: Wskazanym katalogu głównym utwórz folder dla swojej aplikacji PHPixie i przejdź do niego:
bash
```
cd /Applications/ServBay/www
mkdir servbay-phpixie-app
cd servbay-phpixie-app
```
1
2
3
Stwórz nowy projekt PHPixie przez Composer: Wywołaj polecenie Composer w folderze projektu, aby pobrać szablon aplikacji:
bash
```
composer create-project phpixie/project .
```
1
Composer pobierze pliki PHPixie i zależności do bieżącego katalogu.

Konfiguracja serwera WWW

Skorzystaj z funkcji Websites w ServBay, aby ustawić serwer WWW Caddy i wskazać właściwy katalog z projektem PHPixie.

Uruchom aplikację ServBay.
Przejdź do listy Websites.
Dodaj nowy serwis WWW.
Uzupełnij informacje konfiguracyjne:
- Nazwa: np. My First PHPixie Dev Site (wewnętrzna identyfikacja w ServBay).
- Domena: np. servbay-phpixie-test.local (lokalny adres do przeglądarki).
- Typ strony: wybierz PHP.
- Wersja PHP: np. 8.3.
- Katalog główny (Document Root): wskaż katalog web projektu: /Applications/ServBay/www/servbay-phpixie-app/web.
Dlaczego katalog /web?
Plik startowy projektu PHPixie znajduje się w web/index.php. Dla bezpieczeństwa i zgodności z dobrymi praktykami, root serwera WWW powinien wskazywać bezpośrednio na katalog web, a nie główny folder projektu. Zapobiega to bezpośredniemu dostępowi przez WWW do plików konfiguracyjnych lub folderu vendor.
Zapisz konfigurację. ServBay automatycznie skonfiguruje Caddy i — w razie potrzeby — zaktualizuje lokalny plik hosts, przypisując domenę servbay-phpixie-test.local do serwera ServBay.

Szczegółowe kroki znajdziesz w Dodawanie pierwszej strony WWW.

Dodawanie przykładowego kodu

Aby zweryfikować poprawność działania projektu świetnie nada się kilka prostych przykładów integracji z bazą danych i cache.

Stwórz przykładowy kontroler: Dodaj poniższy kod w pliku src/App/HTTP/Controller/Home.php. Jeśli katalog lub plik nie istnieje, utwórz je ręcznie.

php

<?php

namespace App\HTTP\Controller;

use PHPixie\HTTP\Request;
use PHPixie\Template;
use PHPixie\Database\Query; // Dodanie klasy Query

class Home extends \PHPixie\Controller
{
    protected $template;

    public function __construct(Template $template)
    {
        $this->template = $template;
    }

    // Domyślna akcja strony głównej
    public function action_index(Request $request)
    {
        // Renderowanie szablonu assets/templates/app/home.php
        return $this->template->render('app:home');
    }

    // Przykład z Memcached
    public function action_memcached(Request $request)
    {
        $cache = $this->components->cache();
        $cache->set('key', 'Hello Memcached from ServBay!', 60); // Zapisz dane na 60 sekund
        $value = $cache->get('key'); // Pobierz dane
        return $this->response()->string($value); // Zwróć odpowiedź tekstową
    }

    // Przykład z Redis
    public function action_redis(Request $request)
    {
        $redis = $this->components->redis();
        $redis->set('key', 'Hello Redis from ServBay!'); // Zapisz dane
        $value = $redis->get('key'); // Pobierz dane
        return $this->response()->string($value); // Zwróć odpowiedź tekstową
    }

    // Dodawanie użytkownika do MySQL/PostgreSQL
    public function action_add_user(Request $request)
    {
        // Pobierz builder zapytań z komponentu baz danych
        $query = $this->components->database()->query();
        // Dodaj nowy wiersz do tabeli 'users'
        $query->insert('users')->data([
            'name' => 'ServBay Demo User',
            'email' => 'demo-' . uniqid() . '@servbay.test', // Unikalny e-mail
        ])->execute(); // Wykonaj zapis

        return $this->response()->string('User added successfully.'); // Zwróć komunikat sukcesu
    }

    // Pobieranie listy użytkowników z MySQL/PostgreSQL
    public function action_list_users(Request $request)
    {
        // Pobierz builder zapytań z komponentu baz danych
        $query = $this->components->database()->query();
        // Pobierz wszystkich użytkowników z tabeli 'users'
        $users = $query->select('*')->from('users')->execute()->fetchAll(); // Pobierz wyniki

        return $this->response()->json($users); // Zwróć listę użytkowników w JSON
    }
}

Stwórz przykładowy szablon: Dodaj poniższy kod w pliku assets/templates/app/home.php. Utwórz plik i katalog, jeśli nie istnieją.

php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Welcome to PHPixie on ServBay</title>
    <style>
        body { font-family: sans-serif; line-height: 1.6; margin: 20px; }
        h1 { color: #333; }
        p { margin-bottom: 15px; }
        code { background-color: #f4f4f4; padding: 2px 5px; border-radius: 4px; }
        ul { list-style: none; padding: 0; }
        li { margin-bottom: 10px; }
        li a { text-decoration: none; color: #007bff; }
        li a:hover { text-decoration: underline; }
    </style>
</head>
<body>
    <h1>Welcome to PHPixie on ServBay</h1>
    <p>Ta strona została wygenerowana dynamicznie przez Twoją aplikację PHPixie uruchomioną na ServBay.</p>

    <h2>Przykładowe linki do funkcjonalności:</h2>
    <ul>
        <li><a href="/home/memcached">Testuj Memcached</a></li>
        <li><a href="/home/redis">Testuj Redis</a></li>
        <li><a href="/home/add_user">Dodaj użytkownika do bazy</a></li>
        <li><a href="/home/list_users">Wyświetl użytkowników z bazy</a></li>
    </ul>

    <p>Upewnij się, że skonfigurowałeś bazę danych i cache zgodnie z instrukcją.</p>

</body>
</html>

Dostęp do lokalnej strony WWW

Po skonfigurowaniu strony w ServBay i dodaniu kodu przykładowego możesz już przejść do wpisanego wcześniej adresu w przeglądarce:

Otwórz przeglądarkę i odwiedź https://servbay-phpixie-test.local.
Zobaczysz stronę z napisem "Welcome to PHPixie on ServBay" oraz przykładowymi linkami.

Jeśli strona się nie ładuje, sprawdź:

Czy ServBay jest uruchomiony.
Czy konfiguracja strony w ServBay jest poprawna – szczególnie domena, typ strony oraz root folder.
Czy plik hosts właściwie rozpoznaje servbay-phpixie-test.local (ServBay zwykle ustawia to automatycznie).
Czy wybrana wersja PHP jest aktywna w ServBay.

Przykłady integracji z bazą danych i cache

PHPixie natywnie obsługuje różne bazy danych i systemy cache. ServBay dostarcza MySQL, PostgreSQL, Redis, Memcached oraz odpowiednie rozszerzenia PHP, co pozwala łatwo je połączyć z aplikacją PHPixie.

Ważne: Przed użyciem bazy danych upewnij się, że odpowiadający silnik (np. MySQL lub PostgreSQL) jest uruchomiony w ServBay, a baza dla projektu została utworzona (np. o nazwie servbay_phpixie_app). Możesz skorzystać z narzędzi takich jak Sequel Ace, Postico, TablePlus lub terminala. Domyślny użytkownik to zazwyczaj root, a hasło password (zweryfikuj ze swoimi ustawieniami).

Konfiguracja połączenia z bazą danych

W zależności od wybranej bazy edytuj plik assets/config/database.php w katalogu głównym aplikacji. Domyślny adres to 127.0.0.1.

Przykład konfiguracji MySQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // connection — dopasuj do wersji bazy danych i konfiguracji ServBay
        'connection' => 'mysql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Domyślny użytkownik ServBay
        'password'  => 'password', // Domyślne hasło (zmień, jeśli inne)
        'options'   => []
    ]
];

Przykład konfiguracji PostgreSQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // connection — dopasuj do wersji bazy danych i konfiguracji ServBay
        'connection' => 'pgsql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Domyślny użytkownik ServBay
        'password'  => 'password', // Domyślne hasło (zmień, jeśli inne)
        'options'   => []
    ]
];

Tworzenie tabeli bazy (migracje)

PHPixie oferuje CLI do zarządzania migracjami, co umożliwia wersjonowanie struktury bazy danych.

Otwórz terminal: Przejdź do katalogu projektu PHPixie:
bash
```
cd /Applications/ServBay/www/servbay-phpixie-app
```
1
Utwórz plik migracji: Wygeneruj plik migracji do utworzenia tabeli users:
bash
```
php pixie generate:migration create_users_table
```
1
To polecenie utworzy nowy plik w katalogu assets/migrations, nazwa pliku zawiera datę i czas.

Edytuj plik migracji: Przejdź do nowo utworzonego pliku (np. YYYY_MM_DD_HHMMSS_create_users_table.php) i dodaj definicje w metodach up() i down():

php

<?php

use PHPixie\Database\Migration;
use PHPixie\Database\Schema\Table;

class CreateUsersTable extends Migration
{
    public function up()
    {
        // Utworzenie tabeli 'users' przez builder schematu
        $this->schema->create('users', function(Table $table) {
            $table->increments('id'); // Klucz główny AUTOINCREMENT
            $table->string('name'); // Kolumna imię
            $table->string('email')->unique(); // Kolumna email (unikalna)
            $table->timestamps(); // Kolumny created_at, updated_at
        });
    }

    public function down()
    {
        // Usunięcie tabeli 'users'
        $this->schema->drop('users');
    }
}

Uruchom migrację: W terminalu (w katalogu głównym projektu) uruchom:
bash
```
php pixie migrate
```
1
Jeśli wszystko przebiegło poprawnie, wyświetli się komunikat o sukcesie. Sprawdź również w narzędziu DB, że tabela users została utworzona.

Praca z relacyjną bazą danych (MySQL/PostgreSQL)

W powyższym kontrolerze w pliku src/App/HTTP/Controller/Home.php znajdziesz metody action_add_user i action_list_users — pokazują, jak korzystać z komponentu bazy danych do interakcji z MySQL lub PostgreSQL.

Dodawanie użytkownika: Przejdź do https://servbay-phpixie-test.local/home/add_user, aby dodać nowy rekord użytkownika.
Lista użytkowników: Przejdź do https://servbay-phpixie-test.local/home/list_users, by pobrać wszystkich użytkowników w formacie JSON.

Konfiguracja i użycie baz NoSQL (Memcached/Redis)

ServBay posiada wbudowane pakiety Memcached oraz Redis wraz z odpowiednimi rozszerzeniami PHP. Aby je użyć, wystarczy odpowiednio skonfigurować w projekcie PHPixie.

Konfiguracja Memcached (assets/config/cache.php):

Edytuj lub stwórz plik assets/config/cache.php i dodaj poniższe ustawienia:

php

<?php

return [
    'default' => [
        'driver' => 'memcached',
        'servers' => [
            [
                'host'   => '127.0.0.1', // Domyślny adres Memcached w ServBay
                'port'   => 11211, // Domyślny port Memcached
                'weight' => 100,
            ],
        ],
    ],
];

Konfiguracja Redis (assets/config/redis.php):

Edytuj lub stwórz plik assets/config/redis.php i dodaj poniższe ustawienia:

php

<?php

return [
    'default' => [
        'hostname' => '127.0.0.1', // Domyślny adres Redis w ServBay
        'port'     => 6379, // Domyślny port Redis
        'timeout'  => 0,
        'database' => 0, // Index bazy Redis
    ],
];

Korzystanie z Memcached/Redis:

W powyższym kontrolerze src/App/HTTP/Controller/Home.php znajdziesz metody action_memcached i action_redis, które pokazują użycie komponentu cache (konfigurowalny jako Memcached lub Redis).

Testowanie Memcached: Wejdź na https://servbay-phpixie-test.local/home/memcached, aby zapisać wartość do Memcached i odczytać ją.
Testowanie Redis: Wejdź na https://servbay-phpixie-test.local/home/redis, aby zapisać i pobrać wartość do/z Redis.

Upewnij się, że odpowiednie usługi Memcached i Redis są uruchomione w ServBay.

Podsumowanie

Wykonując powyższe kroki, stworzyłeś i uruchomiłeś projekt PHPixie w lokalnym środowisku ServBay na macOS. Nauczyłeś się korzystać z Composer do tworzenia projektu, konfigurować stronę WWW przez funkcję Websites w ServBay, integrować bazę danych oraz cache — i działać na prawdziwym kodzie.

ServBay pozwala szybko i sprawnie zacząć pracę z PHP, eliminując czasochłonne konfiguracje środowiska. Teraz możesz skupić się na rozwijaniu kodu swojej aplikacji PHPixie. Mamy nadzieję, że ten poradnik pomoże Ci szybko zacząć budować kolejne projekty webowe!

Tworzenie i uruchamianie projektu PHPixie na macOS z użyciem ServBay ​

Najważniejsze cechy i zalety PHPixie ​

Tworzenie i uruchamianie projektu PHPixie za pomocą ServBay ​

Wymagania wstępne ​

Tworzenie projektu PHPixie ​

Konfiguracja serwera WWW ​

Dodawanie przykładowego kodu ​

Dostęp do lokalnej strony WWW ​

Przykłady integracji z bazą danych i cache ​

Konfiguracja połączenia z bazą danych ​

Tworzenie tabeli bazy (migracje) ​

Praca z relacyjną bazą danych (MySQL/PostgreSQL) ​

Konfiguracja i użycie baz NoSQL (Memcached/Redis) ​

Podsumowanie ​