Een ThinkPHP 8-project aanmaken en uitvoeren in ServBay

In dit artikel lees je hoe je met ServBay, een krachtige lokale webontwikkelomgeving, snel een PHP-project opzet, configureert en uitvoert op basis van het ThinkPHP 8-framework. ServBay biedt een vooraf ingerichte PHP-omgeving, webservers (Caddy of Nginx) en diverse databases, wat het lokaal opzetten van ThinkPHP-projecten sterk vereenvoudigt.

Wat is ThinkPHP?

ThinkPHP is een opensource, snel en eenvoudig objectgeoriënteerd PHP-ontwikkelframework, afkomstig uit China. Het volgt het principe van eenvoud en efficiëntie en biedt ontwikkelaars een handige toolkit voor het bouwen van moderne webapplicaties. Dankzij het gebruiksgemak, de rijke functies (zoals een krachtige ORM, flexibele routing, ingebouwde template-engine, caching-ondersteuning en meer) en een actieve community, is ThinkPHP breed ingezet in de Chinese PHP-ontwikkelgemeenschap.

Belangrijkste kenmerken en voordelen van ThinkPHP

Eenvoudig en efficiënt: Het framework heeft een strakke opzet en duidelijke code-structuur, wat het begrijpen en onderhouden vergemakkelijkt en de ontwikkelsnelheid verhoogt.
Compleet aan functionaliteit: Bevat veelgebruikte webcomponenten zoals MVC-structuur, ORM, template-engine, caching, sessiebeheer, toegangscontrole, formulier-tokens, enzovoorts.
Krachtige ORM: Biedt een gebruiksvriendelijke en uitgebreide Object Relational Mapping om databasebewerkingen te vereenvoudigen.
Flexibele routing: Ondersteunt verschillende manieren van routedefinitie voor complexe URL-structuren.
Uitgebreid ecosysteem: Beschikt over een groot aanbod van extensielibraries en plugins, plus een actieve ontwikkelingsgemeenschap met veel resources.
Continue updates: Regelmatige frameworkreleases die de laatste ontwikkelingen in de PHP-taal en webontwikkelingsindustrie bijhouden.

ThinkPHP is geschikt voor webontwikkelingsprojecten van klein tot grootschalig, van eenvoudige sites tot grootschalige bedrijfsapplicaties.

ThinkPHP 8-project opzetten met ServBay

ServBay biedt een ideale omgeving voor de lokale ontwikkeling van ThinkPHP 8-projecten, waaronder:

Vooraf geïnstalleerde verschillende PHP-versies met gangbare extensies.
Ingebouwde webservers (Caddy of Nginx), eenvoudig websitebeheer.
Geïntegreerde databaseservices zoals MySQL, PostgreSQL, MongoDB, Redis, Memcached en meer.
Een vooraf geïnstalleerde Composer dependency manager.

In deze handleiding laten we zien hoe je al deze mogelijkheden benut om snel je eigen ThinkPHP 8-project op te zetten.

Benodigdheden

Voordat je begint, zorg dat je het volgende hebt geregeld:

Download en installeer ServBay op macOS.
Start ServBay en zorg dat de benodigde PHP-versie (ThinkPHP 8 vereist PHP 8.0 of hoger) en de gewenste database services (zoals MySQL, PostgreSQL, Redis, Memcached etc.) actief zijn. Je kunt dit controleren en activeren via het tabblad ‘Packages’ op het ServBay-dashboard.

Een ThinkPHP-project aanmaken

Het is een best practice om je lokale websitebestanden centraal in de map /Applications/ServBay/www te plaatsen; zo kan ServBay je projecten optimaal beheren.

Controleer of Composer is geïnstalleerd
ServBay wordt standaard geleverd met Composer voorgeïnstalleerd. Vaak hoef je dus niets extra te installeren. Je kunt dit bevestigen in de ServBay-terminal via het commando composer --version.
Maak een ThinkPHP-project aan met Composer
Open de macOS Terminal en voer het volgende uit om een nieuw ThinkPHP 8-project in de ServBay-webroot aan te maken:
bash
```
cd /Applications/ServBay/www
composer create-project topthink/think servbay-thinkphp-app
```
1
2
Dit maakt een nieuwe map servbay-thinkphp-app aan onder /Applications/ServBay/www en haalt de kernbestanden en afhankelijkheden van ThinkPHP 8 binnen.
Ga naar de projectmap
Ga na het aanmaken van het project naar de projectdirectory:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
```
1

Projectconfiguratie initialiseren

Na het aanmaken van het project voer je enkele basisconfiguraties uit.

Databaseverbinding instellen

ThinkPHP’s database-instellingen vind je doorgaans in config/database.php. Pas dit bestand aan met de juiste verbindingsinformatie, afhankelijk van de gestarte database services in ServBay.

Hieronder zie je een voorbeeldconfiguratie voor de standaard MySQL-dienst van ServBay:

php

<?php
// config/database.php

return [
    // Standaard databaseconnectie
    'default'         => env('database.driver', 'mysql'),

    // Databaseconnecties
    'connections'     => [
        'mysql' => [
            // Type database
            'type'     => 'mysql',
            // Serveradres
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Databasenaam
            'database' => env('database.database', 'servbay_thinkphp_app'), // Maak het liefst een aparte database per project aan
            // Gebruikersnaam
            'username' => env('database.username', 'root'),
            // Wachtwoord
            'password' => env('database.password', 'password'), // ServBay standaardwachtwoord, alleen voor lokaal gebruik!
            // Poort
            'hostport' => env('database.hostport', '3306'),
            // ... Overige instellingen ...
        ],
        // ... Overige databaseverbindingen ...
    ],
];

Belangrijk:

Pas de waarde van database aan naar de daadwerkelijke naam van de database (je kunt bijvoorbeeld met phpMyAdmin of Adminer in ServBay een database servbay_thinkphp_app aanmaken).
Het standaardwachtwoord voor de gebruiker root op ServBay is password. Gebruik dit wachtwoord alleen lokaal en nooit in productie! In productiesituaties gebruik je uiteraard sterke wachtwoorden en maak je een gebruiker met minimale rechten.
Wil je een .env-bestand gebruiken voor je omgevingsvariabelen? Zorg er dan voor dat die waarden standaardinstellingen uit config/database.php overschrijven.

Webserver configureren

Het entrypoint van ThinkPHP is public/index.php, waarbij URL-rewriting nodig is voor correcte routing. Omdat ThinkPHP’s routing afwijkt van puur statische bestanden, gebruiken we de ingebouwde Rewrite-regels van ServBay.

Selecteer in het websitebeheer van ServBay in de dropdown voor Rewrite-regels de optie ThinkPHP en sla op.

Voor gedetailleerde stappen: zie Je eerste website toevoegen.

Voorbeeldcode toevoegen

Om te controleren of de site werkt en ThinkPHP’s basisrouting correct functioneert, voeg je een simpele route en controller toe.

Bewerk /Applications/ServBay/www/servbay-thinkphp-app/route/app.php en voeg onderstaande code toe om een eenvoudige GET-route te definiëren:

php

<?php
// route/app.php

use think\facade\Route;

// Definieer de servbay-route; ontvang een anonieme functie bij bezoek aan /servbay
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... Overige routes ...

De website bezoeken

Na bovenstaande stappen surf je in je browser naar het lokale domein en de route-URL:

https://thinkphp.servbay.demo/servbay

Is alles juist ingesteld, dan zie je de tekst Hello ServBay! in je browser. Dit betekent dat je ThinkPHP 8-project draait in ServBay én dat webserver en PHP-FPM correct geconfigureerd zijn.

NoSQL-databasevoorbeelden

ServBay bevat standaard verschillende NoSQL-databases, zoals Memcached en Redis. ThinkPHP biedt een handige abstraheringslaag voor caching, zodat deze drivers eenvoudig zijn in te stellen als cache.

Memcached-voorbeeld

De Memcached-extensie installeren
ServBay levers Memcached voor PHP standaard mee; je hoeft alleen in het dashboard bij 'Packages' na te gaan of de Memcached-service actief is.

Memcached als cache instellen

Pas config/cache.php aan om ThinkPHP te laten werken met Memcached:

php

<?php
// config/cache.php

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

    // Cacheconnecties
    'stores'  => [
        'memcached' => [
            // Cachetype
            'type'       => 'memcached',
            // Serverlijst
            'host'       => '127.0.0.1', // ServBay Memcached standaardadres
            'port'       => 11211, // ServBay Memcached standaardpoort
            'persistent' => false,
            'expire'     => 0,
            'timeout'    => 0,
            'prefix'     => '',
        ],
        // ... Overige cache-instellingen ...
    ],
];

Memcached-cache in de code gebruiken

Gebruik de Cache Facade van ThinkPHP om Memcached te benutten in een controller of route:

php

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

Route::get('/memcached-example', function () {
    // Zet een cache-item voor 600 seconden
    Cache::set('my_memcached_key', 'This value is from Memcached!', 600);

    // Haal cache op
    $value = Cache::get('my_memcached_key');

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

Test deze route via https://thinkphp.servbay.demo/memcached-example.

Redis-voorbeeld

De Redis-extensie installeren
Ook Redis wordt standaard geleverd met de PHP-pakketten van ServBay. Controleer alleen of de Redis-service actief is via het dashboard.

Redis als cache instellen

Stel config/cache.php in om Redis als driver te gebruiken:

php

<?php
// config/cache.php

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

    // Cacheconnecties
    'stores'  => [
        'redis' => [
            // Cachetype
            'type'       => 'redis',
            // Serveradres
            'host'       => env('cache.host', '127.0.0.1'), // ServBay Redis standaardadres
            // Poort
            'port'       => env('cache.port', 6379), // ServBay Redis standaardpoort
            // Wachtwoord (default geen wachtwoord bij ServBay)
            'password'   => env('cache.password', ''), // Geen wachtwoord standaard
            'select'     => 0,
            'timeout'    => 0,
            'expire'     => 0,
            'persistent' => false,
            'prefix'     => '',
        ],
        // ... Overige cache-instellingen ...
    ],
];

Let op: ServBay’s standaardinstallatie van Redis heeft geen wachtwoord. Mocht je er wél een instellen, vergeet dan niet password hier aan te passen.

Redis-cache in de code gebruiken

Benut de Cache Facade van ThinkPHP in je controllers of routes met Redis:

php

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

Route::get('/redis-example', function () {
    // Zet een cache-item (blijft geldig tenzij je optioneel een vervaltijd als derde parameter opgeeft)
    Cache::set('my_redis_key', 'Hello from Redis!');

    // Haal cache op
    $value = Cache::get('my_redis_key');

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

Test deze route via https://thinkphp.servbay.demo/redis-example.

Voorbeelden met relationele databases

ServBay integreert populaire relationele databases zoals MySQL en PostgreSQL. Via de ORM van ThinkPHP kun je hier moeiteloos mee werken.

Gebruik van ThinkPHP’s database migratietool

In ThinkPHP werk je doorgaans met migrations voor het beheren van schema-aanpassingen, wat samenwerking en versiebeheer vergemakkelijkt.

Database migratietool installeren
Installeer de officiële migration-extensie in de root van je project met Composer:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
composer require topthink/think-migration
```
1
2
Een migratiebestand aanmaken
Maak een nieuwe migration aan; bijvoorbeeld voor de users-tabel:
bash
```
php think migrate:create CreateUserTable
```
1
Dit zorgt voor een nieuw PHP-bestand in de map database/migrations (zoals 20231027100000_create_user_table.php).

Het migratiebestand aanpassen

Open het nieuwe bestand en geef de structuur voor de tabel ‘users’ op in de up()-methode:

php

<?php
// database/migrations/YYYYMMDDHHMMSS_create_user_table.php

use think\migration\Migrator;
use think\migration\db\Column;

class CreateUserTable extends Migrator
{
    /**
     * Wijzigingsmethode.
     *
     * Schrijf hier je omkeerbare migraties.
     *
     * Meer info over migraties: http://docs.phinx.org/en/latest/migrations.html#the-change-method
     *
     * De volgende commando’s worden bij rollback automatisch teruggedraaid:
     *
     * createTable
     * renameTable
     * addColumn
     * addCustomColumn
     * renameColumn
     * addIndex
     * addForeignKey
     * createDatabase
     * renameDatabase
     * dropTable
     * dropColumn
     * dropIndex
     * dropForeignKey
     */
    public function change()
    {
        // Maak een tabel aan via createTable
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Naam van gebruiker'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-mailadres'])
              ->addIndex(['email'], ['unique' => true]) // Unieke index toevoegen
              ->addTimestamps() // Velden created_at en updated_at toevoegen
              ->create(); // Uitvoeren
    }

    // Je kunt ook afzonderlijke up() en down() methodes definiëren
    /*
    public function up()
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Naam van gebruiker'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-mailadres'])
              ->addIndex(['email'], ['unique' => true])
              ->addTimestamps()
              ->create();
    }

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

De migratie uitvoeren
Zorg in de ServBay-terminal dat je in de projectroot zit en voer het volgende uit om de users-tabel aan te maken:
bash
```
php think migrate:run
```
1
Bij succes zie je de nieuwe tabel in je database.

MySQL-voorbeeld

We gaan ervan uit dat MySQL draait in ServBay en correct is ingesteld in config/database.php.

MySQL-verbinding instellen
Zie het voorbeeld in “Projectconfiguratie initialiseren” hierboven en controleer dat de verbinding klopt.

Gegevens toevoegen aan de users-tabel in code

Voeg een gebruiker toe via het Db Facade of een ORM-model. Hieronder een voorbeeld met het 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' => 'demo@servbay.demo', // Voorbeeld e-mail
            'created_at' => date('Y-m-d H:i:s'), // Eventueel handmatig timestamp toevoegen
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'User added successfully!';
    } catch (\Exception $e) {
        return 'Error adding user: ' . $e->getMessage();
    }
});

Test deze via https://thinkphp.servbay.demo/mysql-add-user.

Gegevens uitlezen uit users-tabel in code

Haal gebruikers op via Db Facade of een model:

php

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

Route::get('/mysql-users', function () {
    $users = Db::table('users')->select(); // Haalt alle gebruikers op
    return json($users); // Retourneert als JSON
});

Test dit via https://thinkphp.servbay.demo/mysql-users.

PostgreSQL-voorbeeld

We gaan ervan uit dat PostgreSQL draait in ServBay en goed is ingesteld in config/database.php.

PostgreSQL-verbinding instellen

In config/database.php zorg je voor een extra verbinding zoals hieronder of pas je bestaande gegevens aan:

php

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

return [
    // ... Overige instellingen ...

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

        'pgsql' => [
            // Type database
            'type'     => 'pgsql',
            // Serveradres
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Databasenaam
            'database' => env('database.database', 'servbay_thinkphp_app'), // Bij voorkeur eigen database voor elk project
            // Gebruikersnaam
            'username' => env('database.username', 'root'),
            // Wachtwoord
            'password' => env('database.password', 'password'), // ServBay standaard wachtwoord, alleen lokaal gebruiken!
            // Poort
            'hostport' => env('database.hostport', '5432'), // Standaardpoort van PostgreSQL
            // ... Overige instellingen ...
        ],
        // ... Overige verbindingen ...
    ],
];

Belangrijk:

Maak je eigen PostgreSQL-database aan en stel die hier in.
Ook bij PostgreSQL is het standaardwachtwoord van de gebruiker ‘root’ op ServBay password. Niet geschikt voor productie.

Gegevens toevoegen aan PostgreSQL-gebruikers in code

Voeg een gebruiker toe via het Db Facade, geef expliciet pgsql als verbinding op:

php

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

Route::get('/pgsql-add-user', function () {
    try {
        Db::connect('pgsql')->table('users')->insert([ // Gebruik de pgsql-verbinding
            'name' => 'ServBay PgSQL User',
            'email' => 'pgsql-demo@servbay.demo', // Voorbeeld e-mail
            // Tijdstempels mogelijk handmatig invullen, afhankelijk van migratie en ThinkPHP-versie
            '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();
    }
});

Test deze via https://thinkphp.servbay.demo/pgsql-add-user.

PostgreSQL gebruikers uitlezen in code

Haal gebruikers op via de pgsql-verbinding:

php

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

Route::get('/pgsql-users', function () {
    $users = Db::connect('pgsql')->table('users')->select(); // Haal gebruikers met pgsql-verbinding op
    return json($users); // Als JSON weergeven
});

Test dit via https://thinkphp.servbay.demo/pgsql-users.

Samenvatting

Na het doorlopen van deze stappen heb je succesvol een ThinkPHP 8-project opgezet, geconfigureerd en gestart in je lokale ServBay-omgeving. Je hebt geleerd hoe je met Composer projecten aanmaakt, hoe je de Caddy-webserver met ThinkPHP-routing instelt, en hoe je koppelt met MySQL, PostgreSQL, Memcached en Redis databaseservices van ServBay.

ServBay maakt het lokaal ontwikkelen met PHP-frameworks als ThinkPHP bijzonder eenvoudig, zodat jij je kunt concentreren op de logica van jouw applicatie. Je kunt nu verder bouwen aan je ThinkPHP-app en optimaal gebruikmaken van alle meegeleverde tools en services van ServBay.

Een ThinkPHP 8-project aanmaken en uitvoeren in ServBay ​

Wat is ThinkPHP? ​

Belangrijkste kenmerken en voordelen van ThinkPHP ​

ThinkPHP 8-project opzetten met ServBay ​

Benodigdheden ​

Een ThinkPHP-project aanmaken ​

Projectconfiguratie initialiseren ​

Webserver configureren ​

Voorbeeldcode toevoegen ​

De website bezoeken ​

NoSQL-databasevoorbeelden ​

Memcached-voorbeeld ​

Redis-voorbeeld ​

Voorbeelden met relationele databases ​

Gebruik van ThinkPHP’s database migratietool ​

MySQL-voorbeeld ​

PostgreSQL-voorbeeld ​

Samenvatting ​