Tworzenie i uruchamianie projektu ThinkPHP 8 w ServBay
Ten przewodnik pokaże Ci, jak skorzystać z ServBay – zaawansowanego lokalnego środowiska programistycznego dla web deweloperów – aby szybko utworzyć, skonfigurować i uruchomić aplikację PHP bazującą na frameworku ThinkPHP 8. ServBay zapewnia gotowe środowisko PHP, serwer WWW (Caddy lub Nginx) oraz wiele baz danych, znacznie upraszczając lokalne wdrożenie projektów ThinkPHP.
Czym jest ThinkPHP?
ThinkPHP to szybki, prosty i obiektowy framework PHP open-source, który wywodzi się z Chin. Stawia na czytelność i efektywność, oferując zestaw narzędzi do tworzenia nowoczesnych aplikacji webowych. Framework cieszy się popularnością wśród chińskich developerów PHP dzięki łatwości użycia, bogatym funkcjom (silny ORM, elastyczne routowanie, wbudowany silnik szablonów, obsługa cache) oraz aktywnej społeczności.
Najważniejsze cechy i zalety ThinkPHP
- Prostota i efektywność: Przejrzysta struktura kodu umożliwia szybką naukę, utrzymanie i wydajną pracę zespołową.
- Kompleksowa funkcjonalność: Wbudowane typowe komponenty webowe: MVC, ORM, silnik szablonów, cache, zarządzanie sesjami, autoryzacja, tokeny formularzy.
- Potężny ORM: Umożliwia intuicyjną pracę z bazą danych bez konieczności pisania złożonych zapytań SQL.
- Elastyczne zarządzanie routami: Obsługa różnych typów reguł routingu dla realizacji skomplikowanych struktur URL.
- Bogaty ekosystem: Mnogość rozbudowanych bibliotek, wtyczek i dynamiczna społeczność deweloperów.
- Aktualność: Szybki rozwój frameworka, podążanie za nowościami w PHP i w trendach webowych.
ThinkPHP sprawdza się zarówno w małych projektach, jak i w dużych, korporacyjnych wdrożeniach webowych.
Uruchamianie projektu ThinkPHP 8 w środowisku ServBay
ServBay oferuje idealne warunki do lokalnej pracy nad ThinkPHP 8:
- Gotowe instalacje różnych wersji PHP i niezbędnych rozszerzeń.
- Zintegrowane serwery WWW (Caddy/Nginx) do wygodnej obsługi twoich stron.
- Wsparcie dla MySQL, PostgreSQL, MongoDB, Redis, Memcached i innych popularnych baz danych.
- Wbudowany menedżer zależności – Composer.
W tym przewodniku wykorzystamy te możliwości ServBay do szybkiego uruchomienia projektu ThinkPHP 8.
Wymagania wstępne
Przed rozpoczęciem upewnij się, że wykonałeś poniższe kroki:
- Pobierz i zainstaluj ServBay na systemie macOS lub Windows.
- Uruchom ServBay oraz odpowiednią wersję PHP (ThinkPHP 8 wymaga minimum PHP 8.0) i wszelkie wymagane usługi bazodanowe (np. MySQL, PostgreSQL, Redis, Memcached). Status i uruchamianie usług sprawdzisz w zakładce „Pakiety” w panelu ServBay.
Tworzenie projektu ThinkPHP
Zaleca się, aby pliki twojej strony w ServBay przechowywać w katalogu /Applications/ServBay/www – pozwala to na efektywne zarządzanie projektami.
Sprawdzenie instalacji Composer
ServBay posiada już wbudowanego Composer'a, nie musisz go instalować osobno. Zweryfikujesz jego dostępność komendą
composer --versionw terminalu ServBay.Tworzenie projektu ThinkPHP przez Composer
Otwórz terminal w macOS i wykonaj poniższe polecenia, aby utworzyć nowy projekt ThinkPHP 8 w katalogu głównym stron ServBay:
bashcd /Applications/ServBay/www composer create-project topthink/think servbay-thinkphp-app1
2Komenda utworzy w katalogu
/Applications/ServBay/wwwnowy folderservbay-thinkphp-app, pobierając tam pliki rdzenia ThinkPHP 8 i zależności.Wejdź do katalogu z projektem
Po utworzeniu projektu przejdź do jego katalogu:
bashcd /Applications/ServBay/www/servbay-thinkphp-app1
Wstępna konfiguracja projektu
Po utworzeniu projektu należy przeprowadzić kilka podstawowych ustawień.
Konfiguracja połączenia z bazą danych
Ustawienia bazy danych znajdziesz w pliku
config/database.php. Zależnie od wybranej bazy w ServBay, zmodyfikuj go zgodnie z odpowiednimi parametrami.Przykładowa konfiguracja dla domyślnego MySQL w ServBay:
php<?php // config/database.php return [ // Domyślne ustawienia połączenia z bazą 'default' => env('database.driver', 'mysql'), // Konfiguracje wszystkich baz danych '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'), // Zaleca się osobną bazę dla każdego projektu // Nazwa użytkownika 'username' => env('database.username', 'root'), // Hasło 'password' => env('database.password', 'password'), // Domyślne hasło ServBay, tylko do użycia lokalnego! // Port 'hostport' => env('database.hostport', '3306'), // ... inne ustawienia ... ], // ... inne konfiguracje baz ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Ważne!
- Wartość
databasedopasuj do faktycznej nazwy bazy utworzonej dla projektu (możesz utworzyć ją np. w phpMyAdmin albo Adminer w ServBay). - Domyślnym hasłem do użytkownika
rootw ServBay jestpassword. Hasło należy stosować wyłącznie lokalnie – NIE używaj go w środowisku produkcyjnym! W wersji produkcyjnej stosuj silne hasła i użytkowników o minimalnych uprawnieniach. - Jeśli korzystasz z pliku
.envdo ustawień środowiskowych, zadbaj, aby konfiguracja w.envpoprawnie nadpisywała domyślne wartości zconfig/database.php.
- Wartość
Konfiguracja serwera WWW
Główny plik wejściowy ThinkPHP to public/index.php. Framework wymaga działania reguł Rewrite (przepisywania URL) – bez nich routowanie nie działa poprawnie. W ServBay skorzystasz z gotowych reguł Rewrite.
W panelu ustawień strony, rozwiń menu wyboru reguł Rewrite i wybierz ThinkPHP, następnie zapisz zmiany.
Szczegółowy opis konfiguracji strony w ServBay znajdziesz w dziale Dodawanie pierwszej strony.
Dodawanie przykładowego kodu
Aby sprawdzić, czy konfiguracja i routowanie działają prawidłowo, dodaj prosty przykład routy i kontrolera.
Edytuj plik /Applications/ServBay/www/servbay-thinkphp-app/route/app.php, dodając kod definiujący trasę GET:
php
<?php
// route/app.php
use think\facade\Route;
// Definicja routy servbay – gdy wejdziemy na /servbay, uruchamiany jest kod poniżej
Route::get('servbay', function () {
return 'Hello ServBay!';
});
// ... inne trasy ...1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
Dostęp do strony
Po wykonaniu powyższych kroków, otwórz przeglądarkę i wejdź na skonfigurowaną domenę lokalną wraz z przykładową trasą:
https://thinkphp.servbay.demo/servbay
Jeśli wszystko zostało poprawnie skonfigurowane, zobaczysz w przeglądarce komunikat Hello ServBay!, co oznacza, że Twój projekt ThinkPHP 8 działa prawidłowo w środowisku ServBay, a konfiguracja Web serwera oraz PHP-FPM jest aktywna.
Przykłady integracji baz NoSQL
ServBay oferuje preinstalowane bazy NoSQL, m.in. Memcached i Redis. ThinkPHP posiada wygodną warstwę abstrakcji cache, ułatwiając wykorzystanie tych usług jako silników cache.
Przykład użycia Memcached
Instalacja rozszerzenia Memcached
PHP w ServBay już posiada wbudowaną obsługę Memcached. Musisz tylko upewnić się, że usługa Memcached jest uruchomiona w zakładce „Pakiety” panelu ServBay.
Konfiguracja cache Memcached
Edytuj plik
config/cache.php, by przełączyć ThinkPHP na korzystanie z Memcached:php<?php // config/cache.php return [ // Domyślny silnik cache 'default' => env('cache.driver', 'memcached'), // Konfiguracja połączenia cache 'stores' => [ 'memcached' => [ // Typ cache 'type' => 'memcached', // Lista serwerów 'host' => '127.0.0.1', // Domyślny adres Memcached w ServBay 'port' => 11211, // Domyślny port Memcached ServBay 'persistent' => false, 'expire' => 0, 'timeout' => 0, 'prefix' => '', ], // ... inne konfiguracje cache ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Kod wykorzystujący Memcached
W kontrolerze lub callbacku routy użyj facade
Cachez ThinkPHP, by korzystać z Memcached:php<?php use think\facade\Cache; use think\facade\Route; Route::get('/memcached-example', function () { // Zapisz wartość w cache na 600 sekund Cache::set('my_memcached_key', 'This value is from Memcached!', 600); // Odczytaj z cache $value = Cache::get('my_memcached_key'); return 'Value from Memcached: ' . $value; });1
2
3
4
5
6
7
8
9
10
11
12
13Przetestuj na stronie
https://thinkphp.servbay.demo/memcached-example.
Przykład użycia Redis
Instalacja rozszerzenia Redis
PHP w ServBay zawiera gotowe rozszerzenie Redis – wystarczy uruchomić usługę Redis w panelu „Pakiety”.
Konfiguracja cache Redis
Edytuj plik
config/cache.php, aby ThinkPHP korzystało z Redis jako silnika cache:php<?php // config/cache.php return [ // Domyślny silnik cache 'default' => env('cache.driver', 'redis'), // Konfiguracja połączenia cache 'stores' => [ 'redis' => [ // Typ cache 'type' => 'redis', // Adres serwera 'host' => env('cache.host', '127.0.0.1'), // Domyślny adres Redis w ServBay // Port 'port' => env('cache.port', 6379), // Domyślny port Redis w ServBay // Hasło (domyślnie brak) 'password' => env('cache.password', ''), // Domyślnie Redis nie ma hasła 'select' => 0, 'timeout' => 0, 'expire' => 0, 'persistent' => false, 'prefix' => '', ], // ... inne konfiguracje cache ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Uwaga: Domyślna instalacja Redis w ServBay nie ma ustawionego hasła. Jeśli samodzielnie je dodałeś, nie zapomnij ustawić odpowiedniej wartości w polu
password.Kod wykorzystujący Redis
Użyj facade
Cachew ThinkPHP, by wykonywać operacje na Redis:php<?php use think\facade\Cache; use think\facade\Route; Route::get('/redis-example', function () { // Zapisz wartość w cache bez terminu ważności (lub użyj trzeciego argumentu dla TTL) Cache::set('my_redis_key', 'Hello from Redis!'); // Odczytaj wartość z cache $value = Cache::get('my_redis_key'); return 'Value from Redis: ' . $value; });1
2
3
4
5
6
7
8
9
10
11
12
13Sprawdź pod adresem:
https://thinkphp.servbay.demo/redis-example.
Przykłady użycia baz relacyjnych
ServBay umożliwia korzystanie z MySQL i PostgreSQL – popularnych silników relacyjnych. ThinkPHP ORM pozwala łatwo operować na tych bazach.
Korzystanie z narzędzia migracji w ThinkPHP
W ThinkPHP do zarządzania strukturą bazy używa się narzędzi migracyjnych – ułatwia to współpracę zespołową i kontrolę wersji schematów.
Instalacja narzędzia do migracji
W katalogu głównym projektu zainstaluj narzędzie migracji poleceniem Composer:
bashcd /Applications/ServBay/www/servbay-thinkphp-app composer require topthink/think-migration1
2Tworzenie pliku migracji
Wygeneruj nowy plik migracji przez CLI ThinkPHP, np. do utworzenia tabeli
users:bashphp think migrate:create CreateUserTable1Powstanie nowy plik PHP w katalogu
database/migrations, nazwany z timestampem i twoją nazwą (20231027100000_create_user_table.php).Edycja pliku migracji
Otwórz plik migracji i zmodyfikuj metodę
up(), by zadeklarować strukturę tabeliusers:php<?php // database/migrations/YYYYMMDDHHMMSS_create_user_table.php use think\migration\Migrator; use think\migration\db\Column; class CreateUserTable extends Migrator { /** * Change Method. * * W tej metodzie zapisz zmianę, która może być łatwo cofnięta. * * Więcej o migracjach: http://docs.phinx.org/en/latest/migrations.html#the-change-method * * Można użyć poniższych poleceń; Phinx sam odwróci zmiany przy rollbacku: * * createTable * renameTable * addColumn * addCustomColumn * renameColumn * addIndex * addForeignKey * createDatabase * renameDatabase * dropTable * dropColumn * dropIndex * dropForeignKey */ public function change() { // Utwórz tabelę metodą createTable $table = $this->table('users'); $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Imię użytkownika']) ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adres e-mail']) ->addIndex(['email'], ['unique' => true]) // Indeks unikalny na email ->addTimestamps() // Pola created_at i updated_at ->create(); // Wykonaj utworzenie } // Gdy nie używasz change(), możesz stworzyć oddzielne metody up() i down() /* public function up() { $table = $this->table('users'); $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Imię użytkownika']) ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adres e-mail']) ->addIndex(['email'], ['unique' => true]) ->addTimestamps() ->create(); } public function down() { $this->dropTable('users'); } */ }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60Uruchom migrację
W terminalu ServBay, będąc w katalogu projektu, uruchom komendę migracji:
bashphp think migrate:run1Po powodzeniu w bazie powinna pojawić się nowa tabela
users.
Przykład z MySQL
Zakładamy, że MySQL jest aktywny w ServBay, a w config/database.php są poprawne ustawienia połączenia.
Konfiguracja połączenia MySQL
Skorzystaj z wcześniejszego przykładu z sekcji „Wstępna konfiguracja projektu”, by upewnić się co do poprawności danych w
config/database.php.Dodanie użytkownika do bazy (kod)
Użyj facade
Dblub modelu ORM ThinkPHP do wstawiania danych. Przykład z facade:php<?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 email powiązany z marką 'created_at' => date('Y-m-d H:i:s'), // Timestamp, jeśli addTimestamps() nie ustawia automatycznie 'updated_at' => date('Y-m-d H:i:s'), ]); return 'User added successfully!'; } catch (\Exception $e) { return 'Error adding user: ' . $e->getMessage(); } });1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17Sprawdź pod adresem
https://thinkphp.servbay.demo/mysql-add-user.Odczyt użytkowników z bazy (kod)
Odczyt przez facade
Dblub model ORM:php<?php use think\facade\Db; use think\facade\Route; Route::get('/mysql-users', function () { $users = Db::table('users')->select(); // Pobierz wszystkich użytkowników return json($users); // Zwrot w formacie JSON });1
2
3
4
5
6
7
8Sprawdź pod adresem
https://thinkphp.servbay.demo/mysql-users.
Przykład z PostgreSQL
Zakładamy, że PostgreSQL działa w ServBay, a w config/database.php masz skonfigurowane połączenie.
Konfiguracja połączenia PostgreSQL
Zadbaj, by w pliku
config/database.phpznalazła się konfiguracja jak poniżej (bądź zgodna z twoimi ustawieniami):php<?php // config/database.php (fragment) return [ // ... inne ustawienia ... 'connections' => [ // ... konfiguracja MySQL ... 'pgsql' => [ // Typ bazy 'type' => 'pgsql', // Adres serwera 'hostname' => env('database.hostname', '127.0.0.1'), // Nazwa bazy danych 'database' => env('database.database', 'servbay_thinkphp_app'), // Zaleca się osobną bazę na projekt // Nazwa użytkownika 'username' => env('database.username', 'root'), // Hasło 'password' => env('database.password', 'password'), // Domyślne hasło ServBay – tylko lokalnie! // Port 'hostport' => env('database.hostport', '5432'), // Domyślny port PostgreSQL // ... inne ustawienia ... ], // ... inne konfiguracje baz ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Uwaga!
- Podobnie jak w MySQL, utwórz osobną bazę PostgreSQL dla projektu, wpisz ją w ustawieniach.
- Domyślne hasło PostgreSQL w ServBay to również
password. Wyłącznie do użytku lokalnego.
Dodawanie użytkownika do bazy PostgreSQL
Stosując facade
DbThinkPHP z wybranym połączeniempgsql:php<?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 email // Możliwa manualna obsługa timestampów zależnie od migracji i wersji ThinkPHP 'created_at' => date('Y-m-d H:i:s'), 'updated_at' => date('Y-m-d H:i:s'), ]); return 'PostgreSQL User added successfully!'; } catch (\Exception $e) { return 'Error adding PostgreSQL user: ' . $e->getMessage(); } });1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18Sprawdź pod adresem
https://thinkphp.servbay.demo/pgsql-add-user.Odczyt użytkowników z PostgreSQL
Pobierz dane z bazy przez facade
Dbprzy połączeniupgsql:php<?php use think\facade\Db; use think\facade\Route; Route::get('/pgsql-users', function () { $users = Db::connect('pgsql')->table('users')->select(); // Pobierz z pgsql return json($users); // Zwrot w formacie JSON });1
2
3
4
5
6
7
8Obejrzyj pod adresem
https://thinkphp.servbay.demo/pgsql-usersdane z PostgreSQL.
Podsumowanie
Korzystając z powyższych kroków, stworzyłeś, skonfigurowałeś i uruchomiłeś projekt ThinkPHP 8 w lokalnym środowisku ServBay. Nauczyłeś się jak budować projekt przez Composer, ustawić serwer Caddy i obsłużyć routy frameworka, a także połączyć się i pracować z bazami danych MySQL, PostgreSQL, Memcached oraz Redis.
ServBay znacząco ułatwia lokalną pracę z frameworkami PHP takimi jak ThinkPHP, pozwalając skupić się na rozwoju logiki biznesowej. Możesz teraz rozwijać swoje aplikacje ThinkPHP, wykorzystując szeroki zestaw pakietów i funkcji dostępnych w ServBay.
