Slim-project maken en uitvoeren in ServBay

Deze gids leidt je door het snel creëren, configureren en draaien van een PHP-gebaseerd Slim Framework-project binnen ServBay — de krachtige lokale webontwikkelomgeving. ServBay biedt geïntegreerde PHP, webservers (Caddy/Nginx/Apache) en meerdere database pakketten, waardoor het een ideaal platform is voor Slim-ontwikkeling.

Wat is Slim?

Slim is een lichtgewicht PHP-microframework dat is ontworpen voor het snel bouwen van eenvoudige, maar krachtige webapplicaties en API's. Het biedt core functionaliteit voor routering, request- en response-afhandeling, en is uitermate geschikt voor projecten die snel ontwikkeld en uitgerold moeten worden, of als basis voor complexere applicaties.

Belangrijkste features en voordelen van Slim

Lichtgewicht: De kerncode van het Slim-framework is zeer compact, verbruikt weinig resources en start snel — perfect voor kleine tot middelgrote applicaties of microservices.
Flexibel: Slim is ontworpen als modulair framework, waardoor je eenvoudig elke externe component of bibliotheek kunt integreren (zoals template-engines, ORM's, authenticatie-bibliotheken, enz.), zodat je optimaal kunt kiezen wat past bij jouw project.
Gebruiksvriendelijk: Dankzij de overzichtelijke API en duidelijke documentatie kunnen ontwikkelaars snel de basis begrijpen en aan de slag gaan.
Krachtige routering: Ondersteunt meerdere HTTP-methoden (GET, POST, PUT, DELETE, etc.) en complexe routering, inclusief groepsroutes, middleware en parametric routing.
Middleware-ondersteuning: Via de middleware-laag kun je taken uitvoeren vóór de applicatielogica of voordat een response teruggestuurd wordt naar de client, zoals authenticatie, logging, CORS-afhandeling, enz.

Slim is bij uitstek geschikt voor het bouwen van RESTful API's, snelle prototypes en het afhandelen van specifieke, geïsoleerde functionaliteit.

Een Slim-project opzetten en uitvoeren in ServBay

In deze handleiding maken we gebruik van ServBay's vooraf geconfigureerde PHP-omgeving en de Website-feature om een webserver te configureren en je Slim-project toegankelijk te maken.

Vereisten

Zorg vooraf voor het volgende:

Installeer en start ServBay: Controleer of ServBay correct is geïnstalleerd op macOS of Windows, en dat de ServBay-app draait.
ServBay bevat Composer: Composer is standaard geïntegreerd in ServBay — je hoeft dit niet apart te installeren.

Slim-project aanmaken

ServBay raadt aan om al je projecten in de volgende mapstructuur te plaatsen, wat het beheer en de configuratie eenvoudiger maakt:

macOS: /Applications/ServBay/www
Windows: C:\ServBay\www

Ga naar de ServBay-rootmap:
macOS:
bash
```
cd /Applications/ServBay/www
```
1
Windows:
cmd
```
cd C:\ServBay\www
```
1
Maak een projectmap: Maak een nieuwe directory aan voor je Slim-project.
bash
```
mkdir servbay-slim-app
```
1
Navigeer naar de projectmap:
bash
```
cd servbay-slim-app
```
1
Installeer Slim met Composer: Voer onderstaande composer-opdracht uit in de projectmap om Slim en een PSR-7-implementatie te installeren.
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
Deze opdracht downloadt het Slim-framework en de slim/psr7-bibliotheek in de vendor-map en genereert de composer.json en composer.lock bestanden.

Slim-applicatie initialiseren

Maak het entrypoint bestand: Slim gebruikt meestal één entrypoint (zoals public/index.php) om alle requests af te handelen. Maak hiervoor een public-directory en daarbinnen een index.php aan.
bash
```
mkdir public
touch public/index.php
```
1
2

Bewerk het entrypoint bestand: Open public/index.php en voeg de basiscode voor een Slim-applicatie toe:

php

<?php
// Laad Composer autoload
require __DIR__ . '/../vendor/autoload.php';

// Importeer benodigde PSR-7 interfaces en Slim factory
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

// Maak het Slim-applicatie instance aan
$app = AppFactory::create();

// Voeg een basisroute toe: handelt GET-verzoeken af naar de root '/'
$app->get('/', function (Request $request, Response $response, $args) {
    // Schrijf content naar de response body
    $response->getBody()->write("Hello ServBay!");
    // Stuur de response terug
    return $response;
});

// Start de Slim-applicatie
$app->run();

Deze code maakt een minimalistische Slim-app aan, definieert een route voor de root-URL (/) die bij een GET-verzoek "Hello ServBay!" retourneert.

ServBay-website instellen

Om je Slim-project in de browser te bereiken, moet je een Website configureren in ServBay (voorheen "Host" genoemd).

Open de ServBay-app.
Ga naar de Websites module.
Klik op 'Nieuwe website toevoegen'.
Vul de configuratie in volgens jouw project:
- Naam: My First Slim Dev Site (of een door jou gekozen naam)
- Domein: servbay-slim-test.local (aanbevolen is .local of .test voor lokale ontwikkelomgevingen)
- Website-type: PHP
- PHP-versie: Kies de gewenste versie, bijvoorbeeld 8.3.
- Document Root: Browse naar de public map van je project:
  - macOS: /Applications/ServBay/www/servbay-slim-app/public
  - Windows: C:\ServBay\www\servbay-slim-app\public
  Dit is nodig omdat het entrypoint index.php zich in de public map bevindt en de webserver daarheen moet sturen.
Sla de websiteconfiguratie op. ServBay werkt dan automatisch de webserver-instellingen bij.

Zie voor een uitgebreide stap-voor-stap Eerste website toevoegen.

Je Slim-site bezoeken

Na configuratie kun je in je browser naar het ingestelde domein https://servbay-slim-test.local gaan.

Als alles goed is ingesteld, zie je op de pagina het bericht Hello ServBay! verschijnen, wat betekent dat je Slim-project succesvol draait op ServBay.

Voorbeelden voor database-integratie

Slim heeft zelf geen database-abstractielaag, maar je kunt eenvoudig diverse PHP-databasebibliotheken integreren. Hieronder laten we zien hoe je MySQL en PostgreSQL koppelt via het Eloquent ORM (illuminate/database component van Laravel), plus voorbeelden voor Memcached en Redis.

Vereisten: Database aanmaken en migraties uitvoeren

Voor database-integratie moet je eerst een database aanmaken in ServBay en de benodigde tabellenstructuur opzetten voor je app.

Database aanmaken:
- Open de ServBay-app en ga naar het betreffende databasepakket (MySQL of PostgreSQL).
- Gebruik een managementtool (zoals phpMyAdmin voor MySQL/MariaDB, pgAdmin voor PostgreSQL) of de commandline om een database te maken, bijvoorbeeld servbay_slim_app.
- Het default root-wachtwoord voor databases in ServBay is gewoonlijk password, maar je kunt dit checken of aanpassen in de ServBay interface.

Phinx installeren en configureren (migratietool): Met Phinx kun je eenvoudig database-schema's versiebeheer geven.

Installeer Phinx via Composer in je Slim-project root:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require robmorgan/phinx
```
1

Initialiseer Phinx-configuratie:

bash

vendor/bin/phinx init

Dit maakt een phinx.yml aan in de root van je project. Bewerk het bestand voor je database-connectie:

yaml

paths:
    migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
    seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'

environments:
    default_migration_table: phinxlog
    default_environment: development # of de naam die jij gebruikt

    development: # stel in volgens jouw database
        adapter: mysql # of pgsql
        host: 127.0.0.1
        name: servbay_slim_app # de naam van je database
        user: root
        pass: password # databasewachtwoord
        port: 3306 # MySQL standaard; PostgreSQL standaard is 5432
        charset: utf8mb4 # voor MySQL
        collation: utf8mb4_unicode_ci # voor MySQL

version_order: creation

Migratiebestand maken: Maak een nieuwe migratie met Phinx:

bash

vendor/bin/phinx create CreateUsersTable

Dit genereert een nieuw PHP-bestand in db/migrations. Open het en definieer het users-tabelschema in de change()-methode:

php

<?php

declare(strict_types=1);

use Phinx\Migration\AbstractMigration;

final class CreateUsersTable extends AbstractMigration
{
    /**
     * Change Method.
     *
     * Write your reversible migrations using this method.
     *
     * More information on writing migrations is available here:
     * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
     *
     * Remember to call "create()" or "update()" and NOT "save()" when working
     * with the Table class.
     */
    public function change(): void
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string')
              ->addColumn('email', 'string', ['unique' => true])
              ->addTimestamps() // voegt velden created_at en updated_at toe
              ->create();
    }
}

Migratie uitvoeren: Voer de Phinx-migratie uit in je projectroot om de tabel te maken.
bash
```
vendor/bin/phinx migrate
```
1
Belangrijk: Voer deze stappen uit voordat je de voorbeeldcode voor database gebruikt.

Gebruik van illuminate/database component

We gebruiken het Laravel-databasepakket (illuminate/database) als ORM/query builder.

illuminate/database installeren: Installeer in je projectroot:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require illuminate/database
```
1

Database-connectie instellen in public/index.php: Voeg na require __DIR__ . '/../vendor/autoload.php'; en vóór $app = AppFactory::create(); dit toe voor databaseconfiguratie:

php

// ... andere require en use statements ...

use Illuminate\Database\Capsule\Manager as Capsule; // Importeer Capsule Manager

// Initialiseer Eloquent ORM
$capsule = new Capsule;

// Voeg je databaseconfiguratie toe (pas driver/gegevens aan indien nodig)
$capsule->addConnection([
    'driver' => 'mysql', // of 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // database naam
    'username' => 'root', // db-gebruiker
    'password' => 'password', // db-wachtwoord
    'charset' => 'utf8mb4', // aanbevolen voor MySQL
    'collation' => 'utf8mb4_unicode_ci', // aanbevolen voor MySQL
    'prefix' => '',
    // Voor PostgreSQL is schema nodig:
    // 'schema' => 'public',
]);

// Stel Capsule globaal beschikbaar
$capsule->setAsGlobal();

// Start Eloquent
$capsule->bootEloquent();

// ... maak Slim-app-instance ($app = AppFactory::create();) ...

MySQL Voorbeeld

Als je in ServBay MySQL hebt gestart, de database servbay_slim_app hebt aangemaakt en de migratie uitgevoerd:

Voeg vóór $app->run(); in public/index.php de volgende routes toe:

php

// ... eerdere initialisatie en '/' route ...

use Illuminate\Database\Capsule\Manager as Capsule; // Controleer import

// Route om gebruiker toe te voegen
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // met time() unieke email
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User toegevoegd aan MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Fout bij toevoegen gebruiker: ' . $e->getMessage());
        $response = $response->withStatus(500); // errorstatus
    }
    return $response;
});

// Route om gebruikers op te halen
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // output als JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // header instellen
    } catch (\Exception $e) {
         $response->getBody()->write('Fout bij ophalen gebruikers: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Bezoeken:

Bezoek https://servbay-slim-test.local/mysql-add-user om een gebruiker toe te voegen aan de tabel users.
Bezoek https://servbay-slim-test.local/mysql-get-users om alle gebruikers op te halen in JSON-formaat.

PostgreSQL Voorbeeld

Als je in ServBay PostgreSQL hebt gestart, de database servbay_slim_app hebt aangemaakt en de migratie hebt uitgevoerd (let op instellingen adapter en port: pgsql en 5432):

Wijzig voor PostgreSQL de databaseconfiguratie in public/index.php, verander driver in pgsql en voeg schema toe:

php

$capsule->addConnection([
    'driver' => 'pgsql', // gebruik pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // standaard utf8 voor PostgreSQL
    'prefix' => '',
    'schema' => 'public', // vereiste schema voor PostgreSQL
]);
// ... overige Eloquent-initialisatie ...

Voeg vóór $app->run(); de volgende routes toe:

php

// ... eerdere initialisatie en '/' route ...
// ... MySQL-routes indien nodig ...

use Illuminate\Database\Capsule\Manager as Capsule; // Controleer import

// Route om gebruiker toe te voegen
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test', // unieke email via time()
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User toegevoegd aan PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Fout bij toevoegen gebruiker: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Route om gebruiker op te halen
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Fout bij ophalen gebruikers: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Bezoeken:

Bezoek https://servbay-slim-test.local/pgsql-add-user om een gebruiker toe te voegen aan de PostgreSQL-tabel users.
Bezoek https://servbay-slim-test.local/pgsql-get-users om gebruikers in JSON-formaat op te halen uit PostgreSQL.

Memcached Voorbeeld

ServBay levert een Memcached-pakket plus PHP-extensie ext-memcached. Je hoeft alleen een PHP-clientbibliotheek voor Memcached te installeren; wij gebruiken memcached/memcached.

Installeer Memcached client: Installeer de dependency in je projectroot:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require memcached/memcached
```
1

Voeg Memcached-routes toe in public/index.php: Vóór $app->run();:

php

// ... eerdere initialisatie en database-routes ...

// Route voor Memcached
$app->get('/memcached-example', function (Request $request, Response $response, $args) {
    // Maak een Memcached client aan
    $memcached = new Memcached();
    // Voeg server toe (default ServBay: 127.0.0.1:11211)
    $memcached->addServer('127.0.0.1', 11211);

    $cacheKey = 'my_servbay_cache_key';
    // Probeer data uit cache te halen
    $cachedData = $memcached->get($cacheKey);

    if ($cachedData === false) {
        // Indien leeg, schrijf naar cache en response
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        $memcached->set($cacheKey, $cachedData, 60); // 60 sec TTL
        $response->getBody()->write($cachedData);
    } else {
        // Indien in cache, direct tonen
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

// ... $app->run();

Bezoeken: Bezoek https://servbay-slim-test.local/memcached-example. De eerste keer zie je "This was not cached."; volgende verzoeken tonen "This was served from cache." zolang de cache niet verlopen is.

Redis Voorbeeld

ServBay levert een Redis-pakket plus PHP-extensie ext-redis. Je hoeft alleen een PHP-client te installeren; wij gebruiken predis/predis.

Installeer Redis client: Installeer de dependency in je projectroot:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require predis/predis
```
1

Voeg Redis-routes toe in public/index.php: Vóór $app->run();:

php

// ... eerdere initialisatie, database-routes en eventueel Memcached-routes ...

use Predis\Client as RedisClient; // Importeer Predis client

// Route voor Redis
$app->get('/redis-example', function (Request $request, Response $response, $args) {
    try {
        // Maak Redis-client aan (default ServBay: 127.0.0.1:6379)
        $redis = new RedisClient([
            'scheme' => 'tcp',
            'host' => '127.0.0.1',
            'port' => 6379,
        ]);

        $cacheKey = 'my_servbay_redis_cache_key';
        // Probeer data uit Redis-cache te halen
        $cachedData = $redis->get($cacheKey);

        if ($cachedData === null) {
            // Geen cache: schrijf nieuwe data en in Redis
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            $redis->setex($cacheKey, 60, $cachedData); // 60 sec expire
            $response->getBody()->write($cachedData);
        } else {
            // Indien cached: direct tonen
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // Vang exceptions voor connectie/problemen
        $response->getBody()->write('Fout bij connectie met Redis of operatie uitvoeren: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }

    return $response;
});

// ... $app->run();

Bezoeken: Ga naar https://servbay-slim-test.local/redis-example. Eerste poging geeft "This was not cached."; herhaalde verzoeken tonen "This was served from cache." tot de cache verloopt.

Samenvatting

Door deze stappen te volgen heb je met succes een Slim Framework-project opgezet in de lokale ServBay-ontwikkelomgeving, inclusief de configuratie van een Website voor hosting en bereikbaarheid. Daarnaast heb je geleerd om ServBay's diverse softwarepakketten (MySQL, PostgreSQL, Memcached, Redis) en de betreffende PHP-extensies te integreren voor database- en cachefunctionaliteit binnen je Slim-applicatie. ServBay vereenvoudigt het opzetten en beheren van je lokale stack, zodat je je volledig kunt richten op de ontwikkeling van je Slim-apps.

Slim-project maken en uitvoeren in ServBay ​

Wat is Slim? ​

Belangrijkste features en voordelen van Slim ​

Een Slim-project opzetten en uitvoeren in ServBay ​

Vereisten ​

Slim-project aanmaken ​

Slim-applicatie initialiseren ​

ServBay-website instellen ​

Je Slim-site bezoeken ​

Voorbeelden voor database-integratie ​

Vereisten: Database aanmaken en migraties uitvoeren ​

Gebruik van illuminate/database component ​

MySQL Voorbeeld ​

PostgreSQL Voorbeeld ​

Memcached Voorbeeld ​

Redis Voorbeeld ​

Samenvatting ​