Een ThinkPHP 8-project aanmaken en uitvoeren in ServBay

Deze handleiding laat zien hoe je met ServBay, een krachtig lokaal webontwikkelplatform, snel een PHP-project op basis van het ThinkPHP 8-framework kunt aanmaken, configureren en uitrollen. ServBay voorziet in een voorgeconfigureerde PHP-omgeving, webservers (Caddy of Nginx) en diverse databases, waardoor de lokale opzet van je ThinkPHP-project sterk wordt vereenvoudigd.

Wat is ThinkPHP?

ThinkPHP is een open source, snel en eenvoudig objectgeoriënteerd PHP-framework afkomstig uit China. Het hanteert een heldere en efficiënte ontwikkelfilosofie en biedt ontwikkelaars een uitgebreide toolkit voor het bouwen van moderne webapplicaties. Dankzij de gebruiksvriendelijkheid, rijke mogelijkheden (zoals geavanceerde ORM, flexibele routing, ingebouwde template engine, caching ondersteuning, enz.) en een actieve community kent ThinkPHP veel toepassingen binnen de PHP-ontwikkelgemeenschap in China.

Belangrijkste kenmerken en voordelen van ThinkPHP

• Eenvoudig en efficiënt: Strak ontwerp, heldere code-structuur, goed te onderhouden en met hoge ontwikkelsnelheid.
• Uitgebreide functionaliteit: Inclusief veelgebruikte webontwikkelfunctionaliteiten zoals MVC, ORM, template engine, caching, sessiebeheer, autorisatie en formtokens.
• Krachtige ORM: Maakt databasehandelingen eenvoudig en overzichtelijk dankzij de object-relational mapping.
• Flexibele routing: Ondersteunt diverse routingmethodes, geschikt voor complexe URL-structuren.
• Rijk ecosysteem: Veel uitbreidingen, plugins en een grote actieve ontwikkelgemeenschap met uitgebreide resources.
• Continu up-to-date: Snel opvolgende versies die de ontwikkelingen in PHP en webtrends volgen.

ThinkPHP is geschikt voor projecten van iedere omvang, variërend van kleine websites tot grootschalige business-toepassingen.

ThinkPHP 8 in ServBay opzetten

ServBay biedt een ideaal platform voor de lokale ontwikkeling van ThinkPHP 8-projecten, waaronder:

• Vooraf geïnstalleerde PHP-versies en veelgebruikte extensies.
• Ingebouwde webservers (Caddy of Nginx), eenvoudig websitebeheer.
• Geïntegreerde database-oplossingen: MySQL, PostgreSQL, MongoDB, Redis, Memcached, enz.
• Composer dependency manager ondergebracht.

Deze handleiding gebruikt het ServBay-platform om razendsnel een ThinkPHP 8-project op te zetten.

Voorwaarden

Zorg voor de volgende voorbereidingen voordat je start:

1. Download en installeer ServBay op je macOS of Windows-systeem.
2. ServBay draait, de juiste PHP-versie (ThinkPHP 8 vereist PHP 8.0 of hoger) én de benodigde databaseservices (zoals MySQL, PostgreSQL, Redis, Memcached, enz.) zijn gestart. Open het tabblad “Softwarepakket” in het ServBay-bedieningspaneel om deze te controleren en starten.

Een ThinkPHP-project aanmaken

ServBay raadt aan je lokale websites te beheren in de map /Applications/ServBay/www, zodat ServBay deze optimaal kan managen.

1. Controleer of Composer geïnstalleerd is

   Composer wordt meegeleverd met ServBay, dus normaal hoef je niets extra te doen. Controleer de installatie in je ServBay-terminal met het commando composer --version.

2. Aanmaken van ThinkPHP-project met Composer

   Open de terminal in macOS en voer de volgende commando’s uit om een nieuwe ThinkPHP 8-projectdirectory in de ServBay-root aan te maken:

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

   Hierdoor wordt in /Applications/ServBay/www een nieuwe map servbay-thinkphp-app aangemaakt en worden alle benodigde ThinkPHP 8-bestanden en dependencies gedownload.

3. Ga naar de projectmap

   Zodra het project is aangemaakt, navigeer naar de map:

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

Projectconfiguratie initialiseren

Na het aanmaken van je project is een basisconfiguratie nodig.

1. Databaseverbinding instellen

   De databaseconfiguratie vindt doorgaans plaats in config/database.php. Pas dit bestand aan indien je ServBay-databases gebruikt.

   Hier een voorbeeld van de standaard ServBay MySQL configuratie:

   <?php
   // config/database.php
   
   return [
       // Standaard databaseverbinding
       'default'         => env('database.driver', 'mysql'),
   
       // Databaseverbindingen
       'connections'     => [
           'mysql' => [
               // Database-type
               'type'     => 'mysql',
               // Serveradres
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Databasenaam
               'database' => env('database.database', 'servbay_thinkphp_app'), // Maak bij voorkeur een aparte database aan
               // Gebruikersnaam
               'username' => env('database.username', 'root'),
               // Wachtwoord
               'password' => env('database.password', 'password'), // ServBay standaard wachtwoord, alleen voor lokaal gebruik!
               // Poort
               'hostport' => env('database.hostport', '3306'),
               // ... overige instellingen ...
           ],
           // ... andere verbindingen ...
       ],
   ];

   Belangrijk:

   • Pas de waarde van database aan naar de naam van de daadwerkelijk aangemaakte database voor je project (bijvoorbeeld één die je via phpMyAdmin of Adminer in ServBay aanmaakt).
   • Het standaard wachtwoord voor gebruikersnaam root is password in ServBay. Gebruik dit uitsluitend voor lokale ontwikkeling, NIET in productie! In productie is een sterk wachtwoord en een gebruikersaccount met beperkte rechten essentieel.
   • Als je een .env-bestand gebruikt voor environment variables, zorg er dan voor dat de instellingen daarin de default-waarden in config/database.php overschrijven.

Webserver configureren

Het toegangspunt voor het ThinkPHP-framework is public/index.php, en het relyt op URL-rewrite regels voor routing. ThinkPHP-routing wijkt af van standaard statische bestandsbenadering, dus de meegeleverde Rewrite-regel van ServBay is noodzakelijk.

Kies in de websitesettings “Rewrite regels” dropdown het profiel ThinkPHP en klik op opslaan.

Zie Eerste website toevoegen voor een uitgebreide uitleg over ServBay websitebeheer.

Voorbeeldcode toevoegen

Voeg een simpele route en controller toe om te testen of alles werkt.

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

<?php
// route/app.php

use think\facade\Route;

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

// ... overige routes ...

Website bezoeken

Wanneer bovenstaande stappen zijn gevolgd, open dan een webbrowser en ga naar je lokale domeinnaam en testroute:

https://thinkphp.servbay.demo/servbay

Als alles goed is ingesteld, verschijnt de boodschap Hello ServBay! in de browser. Je ThinkPHP 8-project draait nu correct in de ServBay-omgeving en zowel webserver als PHP-FPM werken zoals verwacht.

NoSQL-databasevoorbeelden

ServBay biedt diverse NoSQL-databases zoals Memcached en Redis. ThinkPHP heeft een abstractielaag voor caching, waarmee je deze services makkelijk als cache-backend kunt integreren.

Memcached-voorbeeld

1. Memcached-extensie installeren

   ServBay levert PHP standaard met de Memcached-extensie. Controleer via het “Softwarepakket”-tabblad in ServBay of Memcached actief is.

2. Memcached-cache configureren

   Bewerk het bestand config/cache.php en stel ThinkPHP in om Memcached als caching driver te gebruiken:

   <?php
   // config/cache.php
   
   return [
       // Standaard caching driver
       'default' => env('cache.driver', 'memcached'),
   
       // Cacheinstellingen
       'stores'  => [
           'memcached' => [
               // Type caching
               'type'       => 'memcached',
               // Serverlijst
               'host'       => '127.0.0.1', // Standaard ServBay Memcached-adres
               'port'       => 11211, // Standaard ServBay Memcached-poort
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... overige cacheinstellingen ...
       ],
   ];

3. Memcached gebruiken in code

   Met ThinkPHP’s Cache Facade kun je in controllers of routes gegevens cachen:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Zet cache met een geldigheid van 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;
   });

   Ga naar https://thinkphp.servbay.demo/memcached-example om te testen.

Redis-voorbeeld

1. Redis-extensie installeren

   ServBay PHP wordt standaard geleverd met de Redis-extensie. Controleer via het “Softwarepakket”-tabblad of Redis actief is.

2. Redis-cache configureren

   Bewerk config/cache.php zodat ThinkPHP Redis als caching driver gebruikt:

   <?php
   // config/cache.php
   
   return [
       // Standaard caching driver
       'default' => env('cache.driver', 'redis'),
   
       // Cacheinstellingen
       'stores'  => [
           'redis' => [
               // Type caching
               'type'       => 'redis',
               // Serveradres
               'host'       => env('cache.host', '127.0.0.1'), // Standaard ServBay Redis-adres
               // Poort
               'port'       => env('cache.port', 6379), // Standaard ServBay Redis-poort
               // Wachtwoord (standaard leeg)
               'password'   => env('cache.password', ''), // ServBay Redis heeft standaard geen wachtwoord
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... overige cacheinstellingen ...
       ],
   ];

   Let op: ServBay’s standaard Redis-installatie gebruikt geen wachtwoord. Indien er handmatig een wachtwoord is gezet, update dan het veld password hier.

3. Redis gebruiken in code

   Gebruik de Cache Facade in je controller of route om Redis te benutten:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Zet cache voor altijd (of gebruik de derde parameter om geldigheid in te stellen)
       Cache::set('my_redis_key', 'Hello from Redis!');
   
       // Haal cache op
       $value = Cache::get('my_redis_key');
   
       return 'Value from Redis: ' . $value;
   });

   Ga naar https://thinkphp.servbay.demo/redis-example om te testen.

Voorbeelden relationele databases

ServBay integreert populaire relationele databases, zoals MySQL en PostgreSQL. Met ThinkPHP’s ORM kun je makkelijk met deze databases communiceren.

Database migratie-tool van ThinkPHP gebruiken

Database migratie is een veelgebruikte manier om wijzigingen in de database structuur te beheren, ideaal voor samenwerking en versiebeheer.

1. De migratietool installeren

   In de root van je project kun je via Composer de ThinkPHP migratie-extensie toevoegen:

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

2. Een migratiebestand aanmaken

   Maak middels de ThinkPHP-cli een nieuw migratiebestand aan, bijvoorbeeld voor de tabel users:

   php think migrate:create CreateUserTable

   Dit genereert een bestand in database/migrations, met een tijdstempel en je gekozen naam, bv. 20231027100000_create_user_table.php.

3. Migratiebestand bewerken

   Open het bestand in database/migrations en definieer de kolommen in de up()-methode:

   <?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()
       {
           // Maak een users-tabel aan
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Gebruikersnaam'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-mailadres'])
                 ->addIndex(['email'], ['unique' => true]) // Voeg een unieke index toe
                 ->addTimestamps() // Voeg created_at en updated_at toe
                 ->create(); // Voer aanmaak uit
       }
   
       // Alternatief voor change(): individuele up() en down() methoden
       /*
       public function up()
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Gebruikersnaam'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'E-mailadres'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Database migratie uitvoeren

   In de ServBay-terminal, zorg dat je in de projectroot bent, en draai de migratie om de users-tabel aan te maken:

   php think migrate:run

   Bij succes is de nieuwe users-tabel in je database zichtbaar.

MySQL-voorbeeld

Veronderstel dat MySQL via ServBay draait en correct is ingesteld in config/database.php.

1. MySQL-verbinding configureren

   Check de MySQL-configuratie zoals hierboven beschreven bij “Projectconfiguratie initialiseren”.

2. Gebruikersdata toevoegen via code

   Plaats bijvoorbeeld dit in een route, gebruikmakend van ThinkPHP’s Db Facade:

   <?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', // ServBay voorbeeld email
               'created_at' => date('Y-m-d H:i:s'), // Voegt tijdstempels toe
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'User added successfully!';
       } catch (\Exception $e) {
           return 'Error adding user: ' . $e->getMessage();
       }
   });

   Ga naar https://thinkphp.servbay.demo/mysql-add-user om dit te testen.

3. Gebruikersdata uitlezen via code

   Gebruik de volgende route om alle gebruikers weer te geven:

   <?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); // Geeft resultaat in JSON
   });

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

PostgreSQL-voorbeeld

Stel PostgreSQL draait via ServBay en is geconfigureerd in config/database.php:

1. PostgreSQL-verbinding instellen

   Voeg in config/database.php een configuratie toe zoals:

   <?php
   // config/database.php (gedeelte)
   
   return [
       // ... overige instellingen ...
   
       'connections'     => [
           // ... MySQL ...
   
           'pgsql' => [
               // Database-type
               'type'     => 'pgsql',
               // Serveradres
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Databasenaam
               'database' => env('database.database', 'servbay_thinkphp_app'), // Maak bij voorkeur een aparte database aan
               // Gebruikersnaam
               'username' => env('database.username', 'root'),
               // Wachtwoord
               'password' => env('database.password', 'password'), // ServBay standaard wachtwoord, alleen voor lokaal gebruik!
               // Poort
               'hostport' => env('database.hostport', '5432'), // Standaard poort PostgreSQL
               // ... overige instellingen ...
           ],
           // ... meer verbindingen ...
       ],
   ];

   Belangrijk:

   • Maak net als bij MySQL een eigen database voor je project aan en stel deze in bij de config.
   • ServBay geeft standaard het wachtwoord password aan het root-account van PostgreSQL. Dit is alleen geschikt voor lokale ontwikkeling.

2. Gebruikersdata toevoegen via PostgreSQL

   Voeg bijvoorbeeld dit toe als route en specificeer de pgsql-verbinding:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-add-user', function () {
       try {
           Db::connect('pgsql')->table('users')->insert([ // Gebruik pgsql-verbinding
               'name' => 'ServBay PgSQL User',
               'email' => 'pgsql-demo@servbay.demo', // ServBay voorbeeld email
               // Voeg tijdstempels toe indien nodig
               '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 via https://thinkphp.servbay.demo/pgsql-add-user.

3. Data uit PostgreSQL uitlezen via code

   Voeg bijvoorbeeld deze route toe:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // Haalt gebruikers op via pgsql
       return json($users); // Geeft resultaat als JSON
   });

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

Samenvatting

Je hebt nu met ServBay een ThinkPHP 8-project lokaal opgezet, geconfigureerd en succesvol uitgevoerd. Je bent bekend geraakt met het gebruik van Composer voor het aanmaken van het project, de configuratie van de Caddy-webserver voor ThinkPHP-routing, en het verbinden met MySQL, PostgreSQL, Memcached en Redis die ServBay aanbiedt.

ServBay maakt het bouwen van lokale ontwikkelomgevingen voor PHP-frameworks als ThinkPHP veel eenvoudiger, zodat je je kunt focussen op het ontwikkelen van je applicatie. Gebruik de diverse pakketten en functies van ServBay en ga verder met het uitbouwen van je ThinkPHP-applicatie.