ThinkPHP 8-Projekte mit ServBay erstellen und ausführen

In diesem Artikel erfahren Sie, wie Sie mit ServBay – einer leistungsstarken lokalen Webentwicklungsumgebung – schnell ein PHP-Projekt auf Basis des ThinkPHP 8 Frameworks erstellen, konfigurieren und ausführen. ServBay bietet vorkonfigurierte PHP-Umgebungen, Webserver (Caddy oder Nginx) sowie verschiedene Datenbanken und vereinfacht damit den lokalen Setup-Prozess für ThinkPHP-Projekte erheblich.

Was ist ThinkPHP?

ThinkPHP ist ein Open-Source PHP-Framework aus China, das für schnelle, einfache und objektorientierte Entwicklung geschaffen wurde. Es basiert auf den Prinzipien von Klarheit und Effizienz und bietet Entwickler:innen eine umfassende Tool-Sammlung zur Erstellung moderner Webanwendungen. Dank seiner Benutzerfreundlichkeit, umfangreichen Features (wie leistungsstarkes ORM, flexibles Routing, integrierter Template-Engine und Caching), sowie einer aktiven Community, ist ThinkPHP im chinesischen PHP-Entwicklungsbereich weit verbreitet.

Wichtigste Merkmale und Vorteile von ThinkPHP

Klar und effizient: Das Framework ist schlank designt, der Code ist übersichtlich und leicht verständlich, wodurch Wartung und Entwicklung schneller werden.
Voll ausgestattetes Framework: Enthält alle Komponenten, die Sie für die Webentwicklung brauchen – MVC-Struktur, ORM, Template-Engine, Caching, Session-Management, Authentifizierung, Form-Tokens und vieles mehr.
Leistungsstarkes ORM: Die objekt-relationale Abbildung vereinfacht und optimiert Datenbankzugriffe erheblich.
Flexibles Routing: Unterstützt unterschiedliche Routendefinitionen, geeignet für komplexe URL-Strukturen.
Großes Ökosystem: Viele Erweiterungen, Plugins und eine aktive Entwickler-Community liefern umfassende Ressourcen.
Kontinuierliche Weiterentwicklung: Regelmäßige Updates sorgen für eine moderne Framework-Infrastruktur und passen sich den neuesten PHP- und Web-Trends an.

ThinkPHP eignet sich ideal für Webprojekte aller Größen – von kleinen Sites bis hin zu komplexen Enterprise-Anwendungen.

ThinkPHP 8-Projekte mit ServBay erstellen

ServBay ist die ideale Umgebung für die lokale Entwicklung mit ThinkPHP 8 und bietet:

Verschiedene PHP-Versionen mit gängigen Erweiterungen vorinstalliert.
Einen integrierten Webserver (Caddy oder Nginx) für einfache Webseiten-Konfiguration.
MySQL, PostgreSQL, MongoDB, Redis, Memcached und weitere Datenbankdienste als Standard.
Vorinstalliertes Composer Dependency Management.

In dieser Anleitung nutzen wir diese Features, um Ihr ThinkPHP 8-Projekt schnell aufzusetzen.

Voraussetzungen

Stellen Sie vor dem Start sicher, dass folgende Vorbereitungen abgeschlossen sind:

ServBay ist auf macOS oder Windows installiert und eingerichtet.
ServBay läuft und die benötigte PHP-Version (ThinkPHP 8 benötigt PHP 8.0 oder neuer) sowie die gewünschten Datenbankdienste (z. B. MySQL, PostgreSQL, Redis, Memcached) sind aktiv. Sie können dies im ServBay Control Panel unter dem Tab „Pakete“ überprüfen und starten.

ThinkPHP-Projekt erstellen

ServBay empfiehlt, Ihre lokalen Webseiten unter /Applications/ServBay/www zu organisieren. Das erleichtert die Verwaltung Ihrer Projekte.

Composer-Installation überprüfen
Composer ist bereits mit ServBay vorinstalliert und muss meist nicht separat eingerichtet werden. Im ServBay-Terminal können Sie mit dem Befehl composer --version dies überprüfen.
ThinkPHP-Projekt mit Composer anlegen
Öffnen Sie das Terminal und führen Sie folgende Befehle im ServBay-Webverzeichnis aus, um ein neues ThinkPHP 8-Projekt zu erstellen:
bash
```
cd /Applications/ServBay/www
composer create-project topthink/think servbay-thinkphp-app
```
1
2
Dies erstellt im Verzeichnis /Applications/ServBay/www einen neuen Ordner servbay-thinkphp-app und lädt alle Kernbestandteile und Abhängigkeiten von ThinkPHP 8.
Ins Projektverzeichnis gehen
Nach dem Anlegen des Projekts wechseln Sie ins Projektverzeichnis:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
```
1

Projektkonfiguration starten

Nach dem Setup passen Sie die wichtigsten Grundeinstellungen an.

Datenbankverbindung konfigurieren

Die Datenbankkonfiguration finden Sie üblicherweise in config/database.php. Passen Sie entsprechend der gestarteten Datenbankdienste in ServBay diese Datei an.

Beispiel für ServBay-Standardkonfiguration mit MySQL:

php

<?php
// config/database.php

return [
    // Standard-Datenbankverbindung
    'default'         => env('database.driver', 'mysql'),

    // Verbindungsdetails der Datenbanken
    'connections'     => [
        'mysql' => [
            // Datenbanktyp
            'type'     => 'mysql',
            // Serveradresse
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Name der Datenbank
            'database' => env('database.database', 'servbay_thinkphp_app'), // Eigene DB pro Projekt empfohlen
            // Benutzername
            'username' => env('database.username', 'root'),
            // Passwort
            'password' => env('database.password', 'password'), // ServBay Standardpasswort, nur lokal verwenden!
            // Port
            'hostport' => env('database.hostport', '3306'),
            // ... weitere Einstellungen ...
        ],
        // ... weitere Datenbankverbindungen ...
    ],
];

Wichtige Hinweise:

Passen Sie den Wert für database auf den tatsächlichen Namen Ihrer Datenbank an (z. B. in phpMyAdmin oder Adminer in ServBay erstellt).
Das root-Passwort von ServBay ist standardmäßig password. Dieses Passwort ist nur für die lokale Entwicklung vorgesehen und darf niemals produktiv eingesetzt werden! Nutzen Sie in Produktionsumgebungen sichere Passwörter und vergeben Sie nur minimale Rechte.
Falls Sie Umgebungsvariablen mit einer .env-Datei verwalten, stellen Sie sicher, dass diese die Werte aus config/database.php korrekt überschreibt.

Webserver konfigurieren

Das Einstiegsskript von ThinkPHP ist public/index.php und verwendet URL-Rewrite-Regeln für die Routing-Logik. Da ThinkPHP Routing von klassischen statischen Zugriffswegen abweicht, wählen Sie in ServBay im Webseitenmenü bei „Rewrite-Regeln“ einfach „ThinkPHP“ und speichern ab.

Für weitere Details zur ServBay-Webseitenkonfiguration siehe Erste Webseite hinzufügen.

Beispielcode hinzufügen

Um die erfolgreiche Konfiguration und Grundfunktionen von ThinkPHP zu testen, legen Sie eine einfache Route und einen Controller an.

Bearbeiten Sie /Applications/ServBay/www/servbay-thinkphp-app/route/app.php und fügen Sie eine GET-Route hinzu:

php

<?php
// route/app.php

use think\facade\Route;

// Definiert die ServBay-Route. Aufruf /servbay führt die anonyme Funktion aus.
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... weitere Routen ...

Webseite aufrufen

Rufen Sie zur Prüfung im Browser Ihre lokale Domain samt Testroute auf:

https://thinkphp.servbay.demo/servbay

Sehen Sie „Hello ServBay!“, läuft Ihr ThinkPHP 8-Projekt erfolgreich in ServBay – inklusive Webserver und PHP-FPM.

NoSQL-Datenbank Beispiel

ServBay bringt Memcached und Redis als NoSQL-Standarddienste mit. Dank des ThinkPHP-Caching-Layers können Sie diese Systeme einfach als Cache-Treiber integrieren.

Beispiel: Memcached

Memcached-Erweiterung prüfen
Die PHP-Erweiterung für Memcached ist bereits in ServBay installiert. Prüfen Sie im Tab „Pakete“ im Control Panel, ob der Dienst läuft.

Memcached-Konfiguration

Bearbeiten Sie config/cache.php und stellen ThinkPHP so ein, dass Memcached als Cache-Treiber verwendet wird:

php

<?php
// config/cache.php

return [
    // Standardcache
    'default' => env('cache.driver', 'memcached'),

    // Cache-Einstellungen
    'stores'  => [
        'memcached' => [
            // Typ des Cache
            'type'       => 'memcached',
            // Serverliste
            'host'       => '127.0.0.1', // Memcached-Standardadresse von ServBay
            'port'       => 11211, // Standard-Port von ServBay-Memcached
            'persistent' => false,
            'expire'     => 0,
            'timeout'    => 0,
            'prefix'     => '',
        ],
        // ... weitere Cache-Konfigurationen ...
    ],
];

Cache in Code nutzen

Mit ThinkPHPs Cache-Facade nutzen Sie Memcached so im Code:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/memcached-example', function () {
    // Cache mit 600 Sekunden Gültigkeit setzen
    Cache::set('my_memcached_key', 'This value is from Memcached!', 600);

    // Cache auslesen
    $value = Cache::get('my_memcached_key');

    return 'Value from Memcached: ' . $value;
});

Testen Sie unter https://thinkphp.servbay.demo/memcached-example.

Beispiel: Redis

Redis-Erweiterung prüfen
Auch Redis ist bereits als PHP-Erweiterung in ServBay installiert. Stellen Sie sicher, dass der Dienst aktiv ist.

Redis-Konfiguration

Bearbeiten Sie config/cache.php, um ThinkPHP auf Redis als Cache-Treiber einzustellen:

php

<?php
// config/cache.php

return [
    // Standardcache
    'default' => env('cache.driver', 'redis'),

    // Cache-Einstellungen
    'stores'  => [
        'redis' => [
            // Cache-Typ
            'type'       => 'redis',
            // Serveradresse
            'host'       => env('cache.host', '127.0.0.1'), // ServBay Redis-Standardadresse
            // Port
            'port'       => env('cache.port', 6379), // Redis-Standard-Port
            // Passwort (Standard: kein Passwort bei ServBay)
            'password'   => env('cache.password', ''), // ServBay benötigt standardmäßig kein Passwort
            'select'     => 0,
            'timeout'    => 0,
            'expire'     => 0,
            'persistent' => false,
            'prefix'     => '',
        ],
        // ... weitere Cache-Konfigurationen ...
    ],
];

Hinweis: Standardmäßig ist Redis in ServBay ohne Passwort eingerichtet. Falls Sie ein Passwort vergeben haben, passen Sie die password-Option entsprechend an.

Cache in Code nutzen

Mit ThinkPHPs Cache-Facade können Sie Redis so nutzen:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/redis-example', function () {
    // Cache setzen (permanent gültig, oder Gültigkeit als dritten Parameter)
    Cache::set('my_redis_key', 'Hello from Redis!');

    // Cache auslesen
    $value = Cache::get('my_redis_key');

    return 'Value from Redis: ' . $value;
});

Testen Sie unter https://thinkphp.servbay.demo/redis-example.

Beispiel: Relationale Datenbanken

ServBay unterstützt MySQL sowie PostgreSQL als Standarddatenbanken. Das ORM von ThinkPHP vereinfacht die Interaktion mit relationalen Datenbanken erheblich.

ThinkPHP Datenbank-Migrationen nutzen

Zur Verwaltung von Datenbankstrukturen empfiehlt sich das Migrationstool von ThinkPHP – dies fördert Teamarbeit und Versionskontrolle.

Migrationstool installieren
Im Projektwurzelverzeichnis installieren Sie via Composer das Migrationstool von ThinkPHP:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
composer require topthink/think-migration
```
1
2
Migration anlegen
Mit ThinkPHPs Kommandozeile legen Sie eine neue Migration, z. B. für die Tabelle users, an:
bash
```
php think migrate:create CreateUserTable
```
1
Im Order database/migrations entsteht eine PHP-Datei, der Name enthält Datum und den gewählten Titel (etwa 20231027100000_create_user_table.php).

Migration bearbeiten

Öffnen Sie die neue Datei und definieren Sie im up()-Abschnitt die Struktur der Tabelle:

php

<?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()
    {
        // Tabelle mit createTable anlegen
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Benutzername'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-Mail-Adresse'])
              ->addIndex(['email'], ['unique' => true]) // Einzigartigen Index hinzufügen
              ->addTimestamps() // created_at und updated_at Felder hinzufügen
              ->create(); // Tabelle erstellen
    }

    // Alternativ können up() und down() getrennt definiert werden
    /*
    public function up()
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Benutzername'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-Mail-Adresse'])
              ->addIndex(['email'], ['unique' => true])
              ->addTimestamps()
              ->create();
    }

    public function down()
    {
        $this->dropTable('users');
    }
    */
}

Migration ausführen
Im ServBay-Terminal – im Projektverzeichnis – führen Sie die Migration mit folgendem Befehl aus:
bash
```
php think migrate:run
```
1
Die Tabelle users wird danach in Ihrer Datenbank angelegt.

MySQL Beispiel

Wenn MySQL in ServBay läuft und in config/database.php konfiguriert ist (wie oben erläutert):

MySQL-Verbindung prüfen
Konfigurieren Sie die MySQL-Verbindung wie im Abschnitt „Projektkonfiguration starten“.

Benutzerdaten schreiben

Mit dem ThinkPHP-Db-Facade oder Modell fügen Sie z. B. einen Benutzer ein:

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', // Beispieladresse
            'created_at' => date('Y-m-d H:i:s'), // Zeitstempel manuell, falls addTimestamps() nicht automatisch
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'User added successfully!';
    } catch (\Exception $e) {
        return 'Error adding user: ' . $e->getMessage();
    }
});

Testzugriff: https://thinkphp.servbay.demo/mysql-add-user.

Benutzerdaten auslesen

Mit Modell oder Facade:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/mysql-users', function () {
    $users = Db::table('users')->select(); // Alle Benutzerdaten
    return json($users); // Als JSON ausgeben
});

Testzugriff: https://thinkphp.servbay.demo/mysql-users.

PostgreSQL Beispiel

Vorausgesetzt, PostgreSQL ist in ServBay gestartet und in config/database.php konfiguriert:

PostgreSQL-Verbindung konfigurieren

Prüfen Sie in config/database.php, ob folgende Konfiguration existiert (ggf. an Ihre Einstellungen anpassen):

php

<?php
// config/database.php (Ausschnitt)

return [
    // ... andere Einstellungen ...

    'connections'     => [
        // ... MySQL ...

        'pgsql' => [
            // Datenbanktyp
            'type'     => 'pgsql',
            // Serveradresse
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Datenbankname
            'database' => env('database.database', 'servbay_thinkphp_app'), // Eigene DB pro Projekt empfohlen
            // Benutzername
            'username' => env('database.username', 'root'),
            // Passwort
            'password' => env('database.password', 'password'), // Nur für lokale Entwicklung!
            // Port
            'hostport' => env('database.hostport', '5432'), // Standard-Port PostgreSQL
            // ... weitere Einstellungen ...
        ],
        // ... weitere Datenbankverbindungen ...
    ],
];

Wichtige Hinweise:

Genau wie bei MySQL empfiehlt sich eine eigene Datenbank pro Projekt.
Das Standard-PostgreSQL-Passwort von ServBay ist ebenfalls password (nur lokal verwenden).

Benutzerdaten schreiben

Speichern Sie mit Db-Facade oder Model Daten und achten Sie darauf, die Verbindung auf pgsql zu setzen:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-add-user', function () {
    try {
        Db::connect('pgsql')->table('users')->insert([ // pgsql-Verbindung nutzen
            'name' => 'ServBay PgSQL User',
            'email' => 'pgsql-demo@servbay.demo', // Beispieladresse
            '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();
    }
});

Testzugriff: https://thinkphp.servbay.demo/pgsql-add-user.

Benutzerdaten auslesen

Auch hier: Verbindung auf pgsql setzen:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-users', function () {
    $users = Db::connect('pgsql')->table('users')->select(); // Daten holen
    return json($users); // Als JSON ausgeben
});

Testzugriff: https://thinkphp.servbay.demo/pgsql-users.

Fazit

Nach diesen Schritten haben Sie mithilfe von ServBay erfolgreich ein ThinkPHP 8-Projekt lokal bereitgestellt und konfiguriert. Sie haben gelernt, wie Sie Composer zur Projektanlage, den Caddy-Webserver zur Routenverarbeitung und die beliebten Datenbankdienste MySQL, PostgreSQL, Memcached oder Redis in ServBay nutzen und einbinden.

ServBay erleichtert das lokale Setup moderner PHP-Frameworks wie ThinkPHP enorm und gibt Ihnen Raum, sich auf Ihre eigentliche Anwendungslogik zu konzentrieren. Sie können nun Ihre ThinkPHP-Anwendung weiter ausbauen und das breite Softwarepaket-Angebot von ServBay voll ausschöpfen.

ThinkPHP 8-Projekte mit ServBay erstellen und ausführen ​

Was ist ThinkPHP? ​

Wichtigste Merkmale und Vorteile von ThinkPHP ​

ThinkPHP 8-Projekte mit ServBay erstellen ​

Voraussetzungen ​

ThinkPHP-Projekt erstellen ​

Projektkonfiguration starten ​

Webserver konfigurieren ​

Beispielcode hinzufügen ​

Webseite aufrufen ​

NoSQL-Datenbank Beispiel ​

Beispiel: Memcached ​

Beispiel: Redis ​

Beispiel: Relationale Datenbanken ​

ThinkPHP Datenbank-Migrationen nutzen ​

MySQL Beispiel ​

PostgreSQL Beispiel ​

Fazit ​