Tworzenie i uruchamianie projektu ThinkPHP 8 w ServBay

Ten artykuł przeprowadzi Cię przez proces szybkiego stworzenia, skonfigurowania i uruchomienia projektu PHP opartego na frameworku ThinkPHP 8 w efektywnym, lokalnym środowisku deweloperskim ServBay. ServBay to gotowe środowisko z prekonfigurowanym PHP, serwerem WWW (Caddy lub Nginx) oraz różnorodnymi bazami danych, co znacząco upraszcza rozwój projektów ThinkPHP na lokalnym komputerze.

Czym jest ThinkPHP?

ThinkPHP to otwarty, szybki i prosty framework programistyczny PHP pochodzący z Chin. Skupia się na czytelnej strukturze oraz efektywności, dostarczając bogaty zestaw narzędzi do budowy nowoczesnych aplikacji WWW. Dzięki łatwości użycia, rozbudowanym funkcjom (m.in. silny ORM, elastyczne routowanie, wbudowany silnik szablonów, wsparcie dla cache) i aktywnej społeczności, cieszy się dużą popularnością wśród chińskich programistów PHP.

Główne cechy i zalety ThinkPHP

• Prostota i efektywność: Przejrzysta struktura kodu oraz logiczna architektura ułatwiają zrozumienie i utrzymanie aplikacji, przyspieszając development.
• Kompleksowa funkcjonalność: Wbudowane mechanizmy typowe dla WWW, takie jak architektura MVC, ORM, silnik szablonów, cache, zarządzanie sesjami, autoryzacja, ochrona formularzy.
• Potężny ORM: Łatwy w użyciu, wydajny system mapowania obiektowo-relacyjnego upraszczający pracę z bazą danych.
• Elastyczne routowanie: Wsparcie dla różnych metod definiowania tras URL – nawet zaawansowanych struktur adresów.
• Bogaty ekosystem: Szeroki wybór rozszerzeń i wtyczek oraz bardzo duża, aktywna społeczność.
• Ciągły rozwój: Szybkie aktualizacje frameworka, nadążające za nowościami PHP i trendami WWW.

ThinkPHP sprawdzi się zarówno w małych projektach, jak i dużych, korporacyjnych aplikacjach internetowych.

Instalacja projektu ThinkPHP 8 w ServBay

ServBay oferuje idealne warunki do lokalnej pracy z ThinkPHP 8:

• Preinstalowane różne wersje PHP wraz z niezbędnymi rozszerzeniami.
• Wbudowany serwer WWW (Caddy lub Nginx) ułatwiający konfigurację stron.
• Integracja z bazami MySQL, PostgreSQL, MongoDB, Redis, Memcached itd.
• Wbudowany menedżer zależności Composer.

Niniejszy przewodnik pokaże, jak wykorzystać te możliwości, by szybko uruchomić swój projekt na ThinkPHP 8.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

1. Pobrałeś i zainstalowałeś ServBay na macOS.
2. ServBay jest uruchomiony, posiadasz aktywną wymaganą wersję PHP (ThinkPHP 8 wymaga minimum PHP 8.0) oraz działające odpowiednie serwisy bazodanowe (np. MySQL, PostgreSQL, Redis, Memcached). Wszystko możesz sprawdzić i aktywować w zakładce „Pakiety” w panelu ServBay.

Tworzenie projektu ThinkPHP

ServBay zaleca przechowywanie lokalnych plików stron WWW w katalogu /Applications/ServBay/www – to ułatwia zarządzanie nimi przez program.

1. Sprawdź instalację Composera

   Composer jest preinstalowany przez ServBay; zwykle nie trzeba niczego doinstalowywać. Weryfikację wykonasz w terminalu ServBay komendą: composer --version.

2. Utwórz projekt ThinkPHP poprzez Composer

   Otwórz terminal macOS i przejdź do katalogu stron, po czym wykonaj polecenie:

   cd /Applications/ServBay/www
   composer create-project topthink/think servbay-thinkphp-app

   W katalogu /Applications/ServBay/www pojawi się folder servbay-thinkphp-app z gotową instalacją ThinkPHP 8 i wymaganymi zależnościami.

3. Wejdź do katalogu projektu

   Po zakończonej instalacji przejdź do folderu z projektem:

   cd /Applications/ServBay/www/servbay-thinkphp-app

Wstępna konfiguracja projektu

Po utworzeniu projektu, należy go poprawnie skonfigurować.

1. Konfiguracja połączenia z bazą danych

   Domyślna konfiguracja bazy danych ThinkPHP znajduje się zwykle w pliku config/database.php. Skoryguj ją zgodnie z uruchomionymi w ServBay serwisami bazodanowymi.

   Przykładowa konfiguracja dla domyślnej bazy MySQL w ServBay:

   <?php
   // config/database.php
   
   return [
       // Domyślne ustawienia połączenia
       'default'         => env('database.driver', 'mysql'),
   
       // Konfiguracja różnych połączeń
       'connections'     => [
           'mysql' => [
               // Typ bazy danych
               'type'     => 'mysql',
               // Adres serwera
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nazwa bazy danych
               'database' => env('database.database', 'servbay_thinkphp_app'), // Zalecane: osobna baza dla projektu
               // Nazwa użytkownika
               'username' => env('database.username', 'root'),
               // Hasło
               'password' => env('database.password', 'password'), // Domyślne hasło ServBay, wyłącznie do developmentu!
               // Port
               'hostport' => env('database.hostport', '3306'),
               // ... inne ustawienia ...
           ],
           // ... inne połączenia ...
       ],
   ];

   Ważne wskazówki:

   • Zmień wartość database na nazwę faktycznie utworzonej dla projektu bazy (stwórz ją np. w phpMyAdmin lub Adminer ServBay, np. o nazwie servbay_thinkphp_app).
   • Domyślne hasło użytkownika root to password. Korzystaj wyłącznie do lokalnych testów! W środowisku produkcyjnym stosuj silne hasła oraz dedykowanych użytkowników o ograniczonych uprawnieniach.
   • Jeśli korzystasz z pliku .env do zarządzania zmiennymi środowiskowymi, dopilnuj, by jego ustawienia nadpisywały wartości z config/database.php.

Konfiguracja serwera WWW

Plikiem wejściowym ThinkPHP jest public/index.php, a framework wymaga prawidłowo ustawionych reguł Rewrite dla trasowania URL. Ponieważ system routingu ThinkPHP różni się od typowej obsługi statycznych plików, w ServBay należy wybrać z listy reguł Rewrite opcję ThinkPHP i zapisać ustawienia.

Szczegóły znajdziesz w poradniku Dodaj pierwszą stronę.

Dodanie przykładowego kodu

Aby przetestować konfigurację oraz sprawdzić podstawowe działanie trasowania ThinkPHP, dodamy prostą trasę i kontroler.

Edytuj plik /Applications/ServBay/www/servbay-thinkphp-app/route/app.php i wklej następującą zawartość:

<?php
// route/app.php

use think\facade\Route;

// Definicja trasy /servbay obsługiwanej przez anonimową funkcję
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... kolejne trasy ...

Dostęp do strony

Po wykonaniu powyższych kroków uruchom w przeglądarce adres odpowiadający lokalnej domenie i przykładowej trasie:

https://thinkphp.servbay.demo/servbay

Jeśli wszystko zostało poprawnie skonfigurowane, zobaczysz w przeglądarce komunikat Hello ServBay!. To oznacza poprawne działanie frameworka ThinkPHP 8 w środowisku ServBay oraz aktywne konfiguracje PHP-FPM i serwera WWW.

Przykłady użycia baz NoSQL

ServBay zapewnia gotowe środowisko dla baz NoSQL, jak Memcached czy Redis. ThinkPHP z kolei dostarcza abstrakcję cache, integrując te serwisy jako backendy pamięci podręcznej.

Przykład użycia Memcached

1. Instalacja rozszerzenia Memcached

   Moduł Memcached jest już preinstalowany w pakiecie PHP od ServBay. Wystarczy upewnić się, że serwis Memcached jest aktywny (sprawdź w zakładce „Pakiety” panelu ServBay).

2. Konfiguracja cache typu Memcached

   W pliku config/cache.php skonfiguruj ThinkPHP do użycia Memcached jako sterownika pamięci podręcznej:

   <?php
   // config/cache.php
   
   return [
       // Domyślny sterownik cache
       'default' => env('cache.driver', 'memcached'),
   
       // Konfiguracja połączeń
       'stores'  => [
           'memcached' => [
               // Typ cache
               'type'       => 'memcached',
               // Adres serwera
               'host'       => '127.0.0.1', // domyślny adres Memcached ServBay
               'port'       => 11211,       // domyślny port Memcached ServBay
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... inne konfiguracje ...
       ],
   ];

3. Korzystanie z Memcached w kodzie

   Użyj fasady Cache ThinkPHP w kontrolerze lub trasie, aby manipulować danymi cache:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Ustawianie cache na 600 sekund
       Cache::set('my_memcached_key', 'This value is from Memcached!', 600);
   
       // Pobieranie z cache
       $value = Cache::get('my_memcached_key');
   
       return 'Value from Memcached: ' . $value;
   });

   Otwórz w przeglądarce https://thinkphp.servbay.demo/memcached-example, aby przetestować.

Przykład użycia Redis

1. Instalacja rozszerzenia Redis

   Rozszerzenie Redis jest preinstalowane w pakiecie PHP ServBay. W zakładce „Pakiety” upewnij się, że serwis Redis jest aktywny.

2. Konfiguracja cache typu Redis

   Skonfiguruj sterownik Redis w pliku config/cache.php:

   <?php
   // config/cache.php
   
   return [
       // Domyślny sterownik cache
       'default' => env('cache.driver', 'redis'),
   
       // Konfiguracja połączeń
       'stores'  => [
           'redis' => [
               // Typ cache
               'type'       => 'redis',
               // Adres serwera
               'host'       => env('cache.host', '127.0.0.1'), // domyślny adres Redis ServBay
               // Port
               'port'       => env('cache.port', 6379),        // domyślny port Redis ServBay
               // Hasło (brak domyślnie)
               'password'   => env('cache.password', ''),      // brak domyślnie
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... inne konfiguracje ...
       ],
   ];

   Uwaga: Domyślnie Redis w ServBay nie ma ustawionego hasła. Jeśli zmienisz to ustawienie, zaktualizuj również pole password w konfiguracji.

3. Korzystanie z cache Redis w kodzie

   Przykład w kontrolerze lub trasie z fasadą Cache:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Ustawianie cache (domyślnie na stałe; dodaj trzeci parametr dla czasu wygasania)
       Cache::set('my_redis_key', 'Hello from Redis!');
   
       // Pobieranie z cache
       $value = Cache::get('my_redis_key');
   
       return 'Value from Redis: ' . $value;
   });

   Odwiedź: https://thinkphp.servbay.demo/redis-example, aby przetestować.

Przykłady użycia relacyjnych baz danych

ServBay zapewnia integrację m.in. z MySQL i PostgreSQL, a ORM ThinkPHP pozwala wygodnie pracować z tymi bazami.

Korzystanie z narzędzi migracji bazy danych ThinkPHP

Zarządzanie strukturą bazy najlepiej realizować poprzez migrations — ułatwia to pracę zespołową i kontrolę wersji.

1. Instalacja narzędzia migracji

   W katalogu głównym projektu zainstaluj rozszerzenie migracji:

   cd /Applications/ServBay/www/servbay-thinkphp-app
   composer require topthink/think-migration

2. Tworzenie pliku migracji

   Wygeneruj plik migracji (np. do utworzenia tabeli users):

   php think migrate:create CreateUserTable

   W katalogu database/migrations/ pojawi się plik PHP z datą, godziną oraz nazwą (np. 20231027100000_create_user_table.php).

3. Edycja pliku migracji

   Otwórz wygenerowany plik i zaimplementuj strukturę tabeli w metodzie up() lub change():

   <?php
   // database/migrations/YYYYMMDDHHMMSS_create_user_table.php
   
   use think\migration\Migrator;
   use think\migration\db\Column;
   
   class CreateUserTable extends Migrator
   {
       /**
        * Change Method.
        *
        * Write your reversible migrations using this method.
        *
        * More information on writing migrations is available here:
        * http://docs.phinx.org/en/latest/migrations.html#the-change-method
        *
        * The following commands can be used in this method and Phinx will
        * automatically reverse them when rolling back:
        *
        * createTable
        * renameTable
        * addColumn
        * addCustomColumn
        * renameColumn
        * addIndex
        * addForeignKey
        * createDatabase
        * renameDatabase
        * dropTable
        * dropColumn
        * dropIndex
        * dropForeignKey
        */
       public function change()
       {
           // Utworzenie tabeli users
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nazwa użytkownika'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adres e-mail'])
                 ->addIndex(['email'], ['unique' => true]) // Unikalny indeks
                 ->addTimestamps() // Pola created_at i updated_at
                 ->create(); // Utwórz tabelę
       }
   
       // Możesz alternatywnie użyć up() i down()
       /*
       public function up()
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nazwa użytkownika'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adres e-mail'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Wykonanie migracji bazy danych

   Uruchom migracje poleceniem:

   php think migrate:run

   Po poprawnym wykonaniu w bazie pojawi się tabela users.

Przykład MySQL

Załóżmy, że MySQL jest już uruchomiony i poprawnie skonfigurowany w config/database.php.

1. Konfiguracja połączenia MySQL

   Upewnij się, że konfiguracja (jak w sekcji dot. wstępnej konfiguracji) zawiera właściwe dane dostępowe.

2. Dodawanie użytkownika do bazy w kodzie

   Przykład użycia fasady Db do inserta:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-add-user', function () {
       try {
           Db::table('users')->insert([
               'name' => 'ServBay Demo User',
               'email' => 'demo@servbay.demo', // przykładowy e-mail
               'created_at' => date('Y-m-d H:i:s'), // timestamps, jeśli nie są automatyczne
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'User added successfully!';
       } catch (\Exception $e) {
           return 'Error adding user: ' . $e->getMessage();
       }
   });

   Przeprowadź test, odwiedzając: https://thinkphp.servbay.demo/mysql-add-user.

3. Wyświetlanie użytkowników w kodzie

   Przykład pobierania danych i zwracania jako JSON:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-users', function () {
       $users = Db::table('users')->select(); // pobierz wszystkich
       return json($users); // wyślij jako JSON
   });

   Zobacz wyniki pod: https://thinkphp.servbay.demo/mysql-users.

Przykład PostgreSQL

Załóżmy, że PostgreSQL jest uruchomiony i skonfigurowany.

1. Konfiguracja połączenia PostgreSQL

   Przykład konfiguracji w config/database.php:

   <?php
   // config/database.php (fragment)
   
   return [
       // ... inne konfiguracje ...
   
       'connections'     => [
           // ... ustawienia MySQL ...
   
           'pgsql' => [
               // Typ bazy danych
               'type'     => 'pgsql',
               // Adres serwera
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nazwa bazy
               'database' => env('database.database', 'servbay_thinkphp_app'), // Zawsze twórz osobną bazę
               // Nazwa użytkownika
               'username' => env('database.username', 'root'),
               // Hasło
               'password' => env('database.password', 'password'), // Domyślne, tylko do testów!
               // Port
               'hostport' => env('database.hostport', '5432'), // domyślny port PostgreSQL
               // ... inne ...
           ],
           // ... inne połączenia ...
       ],
   ];

   Ważne wskazówki:

   • Zalecane jest utworzenie osobnej bazy pod konkretny projekt.
   • Domyślny użytkownik PostgreSQL w ServBay również ma hasło password – używaj wyłącznie lokalnie.

2. Dodawanie użytkownika do PostgreSQL w kodzie

   Użyj połączenia pgsql w fasadzie Db:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-add-user', function () {
       try {
           Db::connect('pgsql')->table('users')->insert([ // Połączenie pgsql
               'name' => 'ServBay PgSQL User',
               'email' => 'pgsql-demo@servbay.demo', // przykładowy e-mail
               'created_at' => date('Y-m-d H:i:s'), // ewentualnie ręcznie timestamps
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'PostgreSQL User added successfully!';
       } catch (\Exception $e) {
            return 'Error adding PostgreSQL user: ' . $e->getMessage();
       }
   });

   Przetestuj pod: https://thinkphp.servbay.demo/pgsql-add-user.

3. Wyświetlanie użytkowników PostgreSQL

   Filtrowanie przez połączenie pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // połączenie pgsql
       return json($users); // JSON
   });

   Zobacz pod: https://thinkphp.servbay.demo/pgsql-users.

Podsumowanie

Wykonując powyższe kroki, zbudowałeś w pełni skonfigurowane, lokalne środowisko deweloperskie do pracy z ThinkPHP 8 za pomocą ServBay. Poznałeś tworzenie projektu przez Composer, konfigurację serwera WWW Caddy/NGINX dla obsługi tras ThinkPHP, podłączanie baz danych (MySQL, PostgreSQL, Memcached i Redis) i praktyczne przykłady implementacji.

ServBay znacząco ułatwia proces budowy środowiska dla aplikacji PHP, dzięki czemu możesz się skoncentrować na logice biznesowej. Rozwijaj swoje aplikacje w ThinkPHP, korzystając z wygody i bogatej funkcjonalności ServBay!