ThinkPHP 8-Projekt in ServBay erstellen und ausführen

In diesem Leitfaden erfahren Sie, wie Sie mit ServBay – einer leistungsstarken lokalen Web-Entwicklungsumgebung – schnell ein PHP-Projekt auf Basis des ThinkPHP 8-Frameworks erstellen, konfigurieren und betreiben. ServBay stellt eine vorkonfigurierte PHP-Umgebung, Webserver (Caddy oder Nginx) und verschiedene Datenbanken bereit und vereinfacht so den lokalen Aufbau von ThinkPHP-Projekten erheblich.

Was ist ThinkPHP?

ThinkPHP ist ein in China entwickeltes, Open-Source, schnelles und einfaches objektorientiertes PHP-Framework. Es folgt dem Prinzip von Klarheit und Effizienz und bietet Entwicklern ein durchdachtes Toolset für den Bau moderner Webanwendungen. ThinkPHP erfreut sich dank seiner Benutzerfreundlichkeit, des umfangreichen Funktionsspektrums (z.B. leistungsfähiges ORM, flexibles Routing, integrierte Template-Engine, Caching) und einer aktiven Community großer Beliebtheit im chinesischen PHP-Umfeld.

Hauptmerkmale und Vorteile von ThinkPHP

Klar und effizient: Das Framework ist schlicht aufgebaut, der Code ist strukturiert und leicht verständlich – dies sorgt für mühelose Wartung und hohe Entwicklungsgeschwindigkeit.
Umfassende Funktionalität: Viele Komponenten für die Webentwicklung sind integriert, darunter MVC-Struktur, ORM, Template-Engine, Caching, Sitzungsverwaltung, Authentifizierung, Formular-Tokens u.v.m.
Leistungsfähiges ORM: Bietet eine starke und einfach zu nutzende objekt-relationale Abbildung und erleichtert so die Datenbankarbeit.
Flexibles Routing: Unterstützt verschiedenste Methoden zur Routenfestlegung, um auch komplexe URL-Strukturen zu ermöglichen.
Reiches Ökosystem: Eine Vielzahl an Erweiterungen, Plugins und eine große, aktive Community stehen bereit.
Kontinuierliche Weiterentwicklung: Schnelle Release-Zyklen und stetige Anpassung an neue PHP- und Webtrends.

ThinkPHP eignet sich hervorragend für Webprojekte jeder Größe – von kleinen Webseiten bis hin zu umfangreichen Enterprise-Lösungen.

ThinkPHP 8-Projekt mit ServBay einrichten

ServBay schafft eine ideale Umgebung für lokale ThinkPHP 8-Entwicklung:

Vorinstallierte PHP-Versionen inklusive häufig genutzter Erweiterungen.
Integrierter Webserver (Caddy oder Nginx) zur einfachen Webseitenkonfiguration.
Datenbankdienste wie MySQL, PostgreSQL, MongoDB, Redis, Memcached.
Integrierter Composer-Abhängigkeitsmanager.

Dieser Leitfaden zeigt, wie Sie mit diesen Features Ihr ThinkPHP 8-Projekt schnell und unkompliziert einrichten.

Voraussetzungen

Vor dem Einstieg sollten folgende Punkte erfüllt sein:

Sie haben ServBay unter macOS heruntergeladen und installiert.
ServBay läuft bereits, und die benötigte PHP-Version (ThinkPHP 8 erfordert PHP 8.0 oder höher) sowie relevante Datenbankdienste ( wie MySQL, PostgreSQL, Redis, Memcached etc.) sind gestartet. Dies können Sie im Reiter „Pakete“ in der ServBay-Systemsteuerung kontrollieren und aktivieren.

ThinkPHP-Projekt erstellen

Es empfiehlt sich, alle lokalen Webseiten unter /Applications/ServBay/www abzulegen – so behält ServBay stets den Überblick über Ihre Projekte.

Sicherstellen, dass Composer installiert ist
ServBay bringt Composer bereits vorinstalliert mit. Über die ServBay-Terminalfunktion können Sie mit dem Befehl composer --version die Installation überprüfen.
ThinkPHP-Projekt via Composer erstellen
Öffnen Sie das macOS-Terminal und legen Sie im Website-Root ein neues ThinkPHP 8-Projekt an:
bash
```
cd /Applications/ServBay/www
composer create-project topthink/think servbay-thinkphp-app
```
1
2
Dadurch wird im Verzeichnis /Applications/ServBay/www der Ordner servbay-thinkphp-app samt aller ThinkPHP-8-Kerndateien und Abhängigkeiten angelegt.
In das Projektverzeichnis wechseln
Nach der Erstellung wechseln Sie ins Projektverzeichnis:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
```
1

Projekt konfigurieren

Nachdem das Projekt erstellt ist, geht es an die grundlegende Konfiguration.

Datenbankverbindung konfigurieren

Die Datenbankeinstellungen finden Sie i.d.R. in config/database.php. Abhängig davon, welcher Datenbankdienst in ServBay aktiviert wurde, passen Sie hier die Zugangsdaten entsprechend an.

Beispiel für die Standard-MySQL-Konfiguration von ServBay:

php

<?php
// config/database.php

return [
    // Standardmäßige Datenbankverbindung
    'default'         => env('database.driver', 'mysql'),

    // Verschiedene Datenbankverbindungen
    'connections'     => [
        'mysql' => [
            // Typ der Datenbank
            'type'     => 'mysql',
            // Serveradresse
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Datenbankname
            'database' => env('database.database', 'servbay_thinkphp_app'), // Am besten für jedes Projekt eine eigene DB
            // 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. können Sie eine Datenbank im ServBay-phpMyAdmin oder Adminer mit dem Namen servbay_thinkphp_app anlegen).
ServBay nutzt standardmäßig "root" als Nutzer und "password" als Passwort. Dieses Passwort dient ausschließlich der lokalen Entwicklung und sollte niemals produktiv verwendet werden! Nutzen Sie für Produktionssysteme stets starke Passwörter und Benutzer mit minimal nötigen Rechten.
Verwenden Sie zur Verwaltung von Umgebungsvariablen ein .env-File, stellen Sie sicher, dass dessen Werte die Standardeinstellungen aus config/database.php überschreiben.

Webserver konfigurieren

Das Entry-File des ThinkPHP-Frameworks ist public/index.php. Zur Routensteuerung werden URL-Rewrite-Regeln benötigt. Da sich das Routing von ThinkPHP von statischen Pfaden unterscheidet, muss auf die internen Rewrite-Regeln von ServBay zurückgegriffen werden.

Wählen Sie im Abschnitt „Rewrite-Regeln“ der Webseite ThinkPHP aus und speichern Sie die Einstellungen.

Detaillierte Infos zur Webseitenkonfiguration finden Sie hier: Erste Webseite hinzufügen.

Beispielcode hinzufügen

Um zu verifizieren, ob die Konfiguration sowie grundlegendes Routing funktionieren, fügen Sie diesem Projekt eine einfache Route mitsamt Controller hinzu.

Bearbeiten Sie /Applications/ServBay/www/servbay-thinkphp-app/route/app.php wie folgt, um eine GET-Route zu definieren:

php

<?php
// route/app.php

use think\facade\Route;

// Definiert die servbay-Route. Ein Aufruf von /servbay startet diese anonyme Funktion
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... weitere Routen ...

Website aufrufen

Öffnen Sie nun Ihren Webbrowser und besuchen Sie Ihre konfigurierte lokale Domain sowie die Beispielroute:

https://thinkphp.servbay.demo/servbay

Erscheint die Ausgabe Hello ServBay!, ist das ThinkPHP 8-Projekt erfolgreich konfiguriert, und Webserver sowie PHP-FPM arbeiten wie gewünscht.

Beispiele für NoSQL-Datenbanken

ServBay enthält zahlreiche NoSQL-Dienste, z.B. Memcached und Redis. ThinkPHP bietet eine flexible Cache-Abstraktion, sodass sich diese Dienste als Cache-Backend kinderleicht anbinden lassen.

Memcached-Beispiel

Memcached-Erweiterung aktivieren
ServBay hat die Memcached-PHP-Erweiterung bereits installiert. Sie müssen lediglich im „Pakete“-Reiter von ServBay sicherstellen, dass der Memcached-Dienst läuft.

Memcached-Cache konfigurieren

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

php

<?php
// config/cache.php

return [
    // Standard-Cache-Treiber
    'default' => env('cache.driver', 'memcached'),

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

Memcached-Cache im Code verwenden

Nutzen Sie im Controller oder Routinen das Cache-Facade für Memcached-Operationen:

php

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

Route::get('/memcached-example', function () {
    // Cache setzen, 600 Sekunden Gültigkeit
    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 über https://thinkphp.servbay.demo/memcached-example.

Redis-Beispiel

Redis-Erweiterung aktivieren
Auch Redis ist als PHP-Erweiterung bereits installiert. Starten Sie im „Pakete“-Menü von ServBay den Redis-Dienst.

Redis als Cache konfigurieren

In config/cache.php kann ThinkPHP für Redis als Caching-Backend eingestellt werden:

php

<?php
// config/cache.php

return [
    // Standard-Cache-Treiber
    'default' => env('cache.driver', 'redis'),

    // Cache-Verbindungen
    'stores'  => [
        'redis' => [
            // Cache-Typ
            'type'       => 'redis',
            // Serveradresse
            'host'       => env('cache.host', '127.0.0.1'), // ServBay Redis-Standardadresse
            // Port
            'port'       => env('cache.port', 6379), // ServBay Redis-Standardport
            // Passwort (standardmäßig leer)
            'password'   => env('cache.password', ''), // Kein Passwort, sofern nicht gesetzt
            'select'     => 0,
            'timeout'    => 0,
            'expire'     => 0,
            'persistent' => false,
            'prefix'     => '',
        ],
        // ... weitere Cache-Konfig ...
    ],
];

Hinweis: Standardmäßig ist bei ServBay Redis kein Passwort gesetzt. Sollten Sie eines vergeben haben, tragen Sie es bitte hier nach.

Redis-Cache im Code verwenden

Über das Cache-Facade können Sie Redis so ansprechen:

php

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

Route::get('/redis-example', function () {
    // Setzt einen Cacheeintrag mit unbegrenzter Laufzeit (oder per drittem Parameter)
    Cache::set('my_redis_key', 'Hello from Redis!');

    // Auslesen des Cachewerts
    $value = Cache::get('my_redis_key');

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

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

Beispiele für relationale Datenbanken

ServBay integriert sowohl MySQL als auch PostgreSQL als starke relationale Datenbanken. ThinkPHP-ORM bietet eine angenehme Schnittstelle zu diesen Systemen.

Datenbankmigrationen mit ThinkPHP

Für Teamarbeit und sauberes Versionieren empfiehlt es sich, für DB-Änderungen das Migrationswerkzeug von ThinkPHP zu nutzen.

Migrationserweiterung installieren
Installieren Sie im Projektstamm die Migrationserweiterung per Composer:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
composer require topthink/think-migration
```
1
2
Migration erstellen
Mit nachfolgendem Befehl wird eine neue Migration für eine users-Tabelle erzeugt:
bash
```
php think migrate:create CreateUserTable
```
1
Die Migration erscheint samt Zeitstempel im Ordner database/migrations (z.B. 20231027100000_create_user_table.php).

Migration bearbeiten

Öffnen Sie die neue Datei und definieren Sie im up()-Methode den Tabellenaufbau:

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()
    {
        // Erstellt eine Tabelle per createTable
        $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]) // Einzigartiger Index für E-Mail
              ->addTimestamps() // Erstellt created_at und updated_at
              ->create();
    }

    // Alternativ können up() / down() einzeln 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
Wechseln Sie ins Projektverzeichnis und starten Sie die Migration:
bash
```
php think migrate:run
```
1
Die Tabelle users wird daraufhin in Ihrer Datenbank erstellt.

MySQL-Beispiel

Sie haben MySQL in ServBay aktiviert und die Verbindung entsprechend wie oben beschrieben konfiguriert.

MySQL-Zugang einrichten
Orientieren Sie sich an der „Projekt-Konfiguration“ weiter oben – insbesondere was config/database.php betrifft.

Benutzerdaten in MySQL speichern

Per ThinkPHP-Db-Facade oder per ORM können Sie Benutzer speichern. Hier ein Beispiel via Db-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' => '[email protected]', // Beispiel-E-Mail mit Branding
            'created_at' => date('Y-m-d H:i:s'), // Zeitstempel ggf. manuell setzen
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'User added successfully!';
    } catch (\Exception $e) {
        return 'Error adding user: ' . $e->getMessage();
    }
});

Testen unter https://thinkphp.servbay.demo/mysql-add-user.

Nutzerdaten aus MySQL auslesen

Per Db-Facade können Sie so die Nutzer abfragen:

php

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

Route::get('/mysql-users', function () {
    $users = Db::table('users')->select(); // Alle User abrufen
    return json($users); // Als JSON zurückgeben
});

Testen unter https://thinkphp.servbay.demo/mysql-users.

PostgreSQL-Beispiel

Auch PostgreSQL kann aus ServBay heraus genutzt werden und wird analog konfiguriert.

PostgreSQL-Anbindung konfigurieren

In config/database.php sollte ein Abschnitt wie folgt enthalten sein:

php

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

return [
    // ... weitere Einstellungen ...

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

        'pgsql' => [
            // Typ der Datenbank
            'type'     => 'pgsql',
            // Serveradresse
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Datenbankname
            'database' => env('database.database', 'servbay_thinkphp_app'), // Eigene DB pro Projekt
            // Benutzername
            'username' => env('database.username', 'root'),
            // Passwort
            'password' => env('database.password', 'password'), // ServBay-Standardpasswort, nur lokal verwenden!
            // Port
            'hostport' => env('database.hostport', '5432'), // PostgreSQL-Standardport
            // ... Weitere Einstellungen ...
        ],
        // ... weitere Verbindungen ...
    ],
];

Wichtige Hinweise:

Legen Sie auch für PostgreSQL pro Projekt eigene Datenbanken an.
Das Defaultpasswort für den Nutzer root ist "password" – ausschließlich für lokale Entwicklung!

Benutzerdaten in PostgreSQL speichern

Per Db-Facade, dieses Mal unter Angabe von pgsql als Verbindung:

php

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

Route::get('/pgsql-add-user', function () {
    try {
        Db::connect('pgsql')->table('users')->insert([ // Verbindung: pgsql
            'name' => 'ServBay PgSQL User',
            'email' => '[email protected]', // Beispiel-Mail mit Branding
            // Eventuell müssen Zeitstempel manuell gesetzt werden
            '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();
    }
});

Testen über https://thinkphp.servbay.demo/pgsql-add-user.

Nutzerdaten aus PostgreSQL auslesen

Mit der Facade und explizit ausgewählter pgsql-Verbindung:

php

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

Route::get('/pgsql-users', function () {
    $users = Db::connect('pgsql')->table('users')->select(); // Zugriff via pgsql
    return json($users); // Ergebnis als JSON
});

Testen über https://thinkphp.servbay.demo/pgsql-users.

Fazit

Sie haben jetzt mit dem ServBay-Entwicklungsumfeld ein ThinkPHP-8-Projekt lokal erstellt, konfiguriert und getestet. Sie wissen, wie Sie mit Composer ein neues Projekt starten, Caddy als Webserver für ThinkPHP passend einrichten und die verschiedenen Datenbankdienste (MySQL, PostgreSQL, Memcached, Redis) von ServBay integrieren.

ServBay nimmt Ihnen viel Konfigurationsaufwand ab und macht die Entwicklung mit PHP-Frameworks wie ThinkPHP lokal zum Kinderspiel. Sie können sich somit ganz auf die Anwendungslogik konzentrieren und sämtliche von ServBay bereitgestellten Werkzeuge optimal nutzen.

ThinkPHP 8-Projekt in ServBay erstellen und ausführen ​

Was ist ThinkPHP? ​

Hauptmerkmale und Vorteile von ThinkPHP ​

ThinkPHP 8-Projekt mit ServBay einrichten ​

Voraussetzungen ​

ThinkPHP-Projekt erstellen ​

Projekt konfigurieren ​

Webserver konfigurieren ​

Beispielcode hinzufügen ​

Website aufrufen ​

Beispiele für NoSQL-Datenbanken ​

Memcached-Beispiel ​

Redis-Beispiel ​

Beispiele für relationale Datenbanken ​

Datenbankmigrationen mit ThinkPHP ​

MySQL-Beispiel ​

PostgreSQL-Beispiel ​

Fazit ​