Een Slim Project Aanmaken en Draaien in ServBay

In dit artikel leer je hoe je snel een PHP Slim Framework-project opzet, configureert en uitvoert binnen ServBay – een krachtige lokale webontwikkelomgeving. ServBay biedt geïntegreerde PHP, webservers (Caddy/Nginx/Apache) en diverse databasepakketten, waardoor het een ideaal platform is voor Slim-ontwikkeling.

Wat is Slim?

Slim is een lichtgewicht PHP microframework, ontworpen om snel eenvoudige maar krachtige webapplicaties en API’s te bouwen. Het biedt essentiële functionaliteiten als routing, request- en response-afhandeling, en is perfect voor projecten die snelle ontwikkeling en implementatie vereisen, of als basis voor complexere applicaties.

Belangrijkste Kenmerken en Voordelen van Slim

Lichtgewicht: De kerncode van Slim is zeer compact, gebruikt weinig resources en start snel op — ideaal voor kleine tot middelgrote applicaties of microservices.
Flexibel: Slim is modulair opgebouwd en laat zich eenvoudig integreren met allerlei externe componenten of libraries (zoals template-engines, ORM’s, authenticatiemodules, enz.), zodat je de tools kunt kiezen die het beste passen bij de vereisten van jouw project.
Gebruiksvriendelijk: Dankzij de overzichtelijke API en heldere documentatie kunnen ontwikkelaars snel aan de slag en de kernconcepten begrijpen.
Krachtige Routing-mogelijkheden: Ondersteuning voor diverse HTTP-methodes (GET, POST, PUT, DELETE, enz.) en flexibele routeringsconfiguraties, zoals routegroepen, middleware en parameters.
Middleware-ondersteuning: Met Slim’s middleware-laag kun je taken uitvoeren vóórdat een request de applicatielogica bereikt of voordat een response naar de client wordt gestuurd, zoals authenticatie, logging of CORS-afhandeling.

Slim is bijzonder geschikt voor het bouwen van RESTful API’s, rapid prototyping en applicaties of modules met specifieke, zelfstandige functionaliteit.

Een Slim Project Aanmaken en Draaien met ServBay

Deze handleiding gebruikt ServBay’s voorgedefinieerde PHP-omgeving en de Website-functie voor het opzetten van een webserver en het toegankelijk maken van je Slim-project via het web.

Vereisten

Zorg ervoor dat je de volgende stappen hebt afgerond:

Installeer en start ServBay: Installeer ServBay op je macOS-systeem en zorg dat de toepassing actief is.
Composer in ServBay: Composer is standaard geïntegreerd in ServBay; je hoeft niets apart te installeren.

Een Slim Project Aanmaken

ServBay raadt aan al je webprojecten te plaatsen in de map /Applications/ServBay/www — dit maakt het beheer en de configuratie eenvoudiger.

Navigeer naar de webroot van ServBay:
bash
```
cd /Applications/ServBay/www
```
1
Maak een projectmap: Maak een nieuwe map aan voor je Slim-project.
bash
```
mkdir servbay-slim-app
```
1
Ga naar de projectmap:
bash
```
cd servbay-slim-app
```
1
Installeer Slim via Composer: Installeer het Slim-framework en de PSR-7-implementatie in je projectmap.
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
Deze opdracht downloadt zowel het Slim-framework als de slim/psr7 library in de vendor-map van je project, en maakt een composer.json en composer.lock aan.

De Slim Applicatie Initialiseren

Creëer het entrypoint-bestand: Slim-projecten gebruiken meestal één entrypoint-bestand (zoals public/index.php) om alle requests af te handelen. Maak in de projectroot de map public aan en voeg daar het bestand index.php toe.
bash
```
mkdir public
touch public/index.php
```
1
2

Bewerk het entrypoint-bestand: Open public/index.php en voeg deze basiscode toe:

php

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

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

// Maak een nieuw Slim-applicatie-instance
$app = AppFactory::create();

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

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

Deze code zet de eenvoudigste Slim-app op: een route voor de root-URL (/) die "Hello ServBay!" laat zien.

ServBay Website Configureren

Om je Slim-project via de browser te kunnen bereiken, moet je een Website instellen in ServBay (voorheen “Host” genoemd).

Open het ServBay-programma.
Navigeer naar het Websites-gedeelte.
Klik om een nieuwe website toe te voegen.
Vul deze instellingen in:
- Naam (Name): My First Slim Dev Site (of een naam naar keuze)
- Domein (Domain): servbay-slim-test.local (gebruik bij voorkeur een .local of .test domein voor lokale ontwikkeling)
- Websitetype (Website Type): PHP
- PHP Versie (PHP Version): selecteer bijvoorbeeld 8.3.
- Documentroot (Document Root): Via de browse-knop kies je het public-mapje van je project: /Applications/ServBay/www/servbay-slim-app/public. De Slim entrypoint index.php zit immers hierin; de webserver moet op dit mapje wijzen.
Sla de websiteconfiguratie op. ServBay werkt dan automatisch de server-instellingen bij en maakt ze actief.

Voor een gedetailleerde handleiding, zie Je eerste website toevoegen.

Je Slim Site Benaderen

Klaar met configureren? Open dan je browser en ga naar de gekozen domeinnaam, bijvoorbeeld: https://servbay-slim-test.local.

Indien alles correct is, verschijnt "Hello ServBay!" op de webpagina. Dit betekent dat je Slim-project succesvol draait via de ServBay-webserver.

Voorbeelden van Database-integratie

Het Slim-framework bevat zelf geen database-abstractie, maar is eenvoudig te koppelen aan diverse PHP-datalibraries. In dit voorbeeld laten we zien hoe je MySQL en PostgreSQL koppelt via Laravel's Eloquent ORM (illuminate/database). Ook krijg je voorbeelden voor Memcached en Redis-integratie.

Voorbereiding: Database Aanmaken en Migrations Draaien

Voordat je database-integratie doet, maak je eerst de benodigde databases aan in ServBay, samen met de tabellen.

Database aanmaken:
- Open ServBay, ga naar het betreffend databasepakket (bijv. MySQL of PostgreSQL).
- Maak een nieuwe database aan (bijv. servbay_slim_app) met de beheertools van ServBay (zoals phpMyAdmin voor MySQL/MariaDB, pgAdmin voor PostgreSQL) of via de commandline.
- De standaard root-wachtwoorden zijn meestal password; je kunt dit controleren of aanpassen in de ServBay-interface.

Installeer en configureer Phinx (database migration tool): Phinx is een populaire PHP-migratietool voor versiebeheer van database-schema’s.

Installeer Phinx in de projectroot /Applications/ServBay/www/servbay-slim-app:
bash
```
composer require robmorgan/phinx
```
1

Initialiseer de Phinx-configuratie:

bash

vendor/bin/phinx init

Hierdoor wordt een phinx.yml-bestand in de projectroot aangemaakt. Pas deze aan voor jouw database, bijvoorbeeld:

yaml

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

environments:
    default_migration_table: phinxlog
    default_environment: development # Of welke naam je kiest

    development: # Configureer naar gekozen database
        adapter: mysql # of pgsql
        host: 127.0.0.1
        name: servbay_slim_app # jouw database-naam
        user: root
        pass: password # je database-wachtwoord
        port: 3306 # MySQL default, PostgreSQL 5432
        charset: utf8mb4 # Advies voor MySQL
        collation: utf8mb4_unicode_ci # Advies voor MySQL

version_order: creation

Maak een migratiebestand aan: Gebruik Phinx om een nieuwe migration te genereren.

bash

vendor/bin/phinx create CreateUsersTable

Dit maakt een PHP-bestand aan in db/migrations/. Open het bestand en definieer de tabelstructuur 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 created_at en updated_at veld toe
              ->create();
    }
}

Migration uitvoeren: Voer in de projectroot het Phinx-commando uit om de migratie te draaien en de users-tabel aan te maken.
bash
```
vendor/bin/phinx migrate
```
1
Belangrijk: Voer altijd eerst het database-aanmaken en migreren uit vooraleer onderstaande codes te gebruiken.

Gebruik van het illuminate/database Component

We gebruiken Laravel’s databasecomponent (illuminate/database) als ORM/query builder.

Installeer illuminate/database: Voeg in de projectroot /Applications/ServBay/www/servbay-slim-app de afhankelijkheid toe:
bash
```
composer require illuminate/database
```
1

Initialiseer de databaseverbinding in public/index.php: Voeg na require __DIR__ . '/../vendor/autoload.php'; en voor het aanmaken van de Slim-app $app = AppFactory::create(); het volgende toe:

php

// ... overige require- en use-statements ...

use Illuminate\Database\Capsule\Manager as Capsule; // Importeer de Capsule-manager

// Initialiseer Eloquent ORM
$capsule = new Capsule;

// Voeg databaseconfiguratie toe (pas driver en parameters aan naar jouw database)
$capsule->addConnection([
    'driver' => 'mysql', // Of 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // Database naam
    'username' => 'root', // Database gebruiker
    'password' => 'password', // Database wachtwoord
    'charset' => 'utf8mb4', // Adviserend voor MySQL
    'collation' => 'utf8mb4_unicode_ci', // Adviserend voor MySQL
    'prefix' => '',
    // PostgreSQL vereist het parameter schema
    // 'schema' => 'public',
]);

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

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

// ... Maak een nieuw Slim-app ($app = AppFactory::create();) ...

MySQL Voorbeeld

Neem aan dat je in ServBay MySQL hebt gestart, de database servbay_slim_app hebt aangemaakt, en via Phinx de users-tabel hebt aangemaakt.

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

php

// ... init-code en '/' route hierboven ...

use Illuminate\Database\Capsule\Manager as Capsule; // Zorg dat deze is geïmporteerd

// Route om een 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', // Gebruik time() voor unieke e-mail
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500); // Stuur foutstatus terug
    }
    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'); // Zet content-type
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Toegang:

Ga naar https://servbay-slim-test.local/mysql-add-user om een nieuwe gebruiker toe te voegen.
Ga naar https://servbay-slim-test.local/mysql-get-users om alle gebruikers in JSON te bekijken.

PostgreSQL Voorbeeld

Stel dat ServBay PostgreSQL draait, je de database servbay_slim_app hebt en de users-tabel is aangemaakt (controleer in Phinx dat adapter en port correct als pgsql en 5432 staan).

Pas in public/index.php de database-verbinding aan: driver wordt pgsql en voeg een schema-parameter toe:

php

$capsule->addConnection([
    'driver' => 'pgsql', // Nu pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL gebruikt meestal utf8
    'prefix' => '',
    'schema' => 'public', // Vereist door PostgreSQL
]);
// ... overig Eloquent-init blijft gelijk ...

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

php

// ... initialisatie en '/' route ...
// ... (optioneel) MySQL-routes ...

use Illuminate\Database\Capsule\Manager as Capsule; // Zorg dat deze is geïmporteerd

// Route om gebruikers 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 e-mail d.m.v. time()
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Route om gebruikers 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('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Toegang:

Ga naar https://servbay-slim-test.local/pgsql-add-user om een gebruiker te voegen aan de PostgreSQL users-tabel.
Ga naar https://servbay-slim-test.local/pgsql-get-users om alle gebruikers als JSON te bekijken.

Memcached Voorbeeld

ServBay levert een Memcached-pakket en de PHP-extensie ext-memcached. Je hoeft alleen een client-library te installeren; in dit voorbeeld is dat memcached/memcached.

Installeer Memcached-client: In de projectroot:
bash
```
composer require memcached/memcached
```
1

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

php

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

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

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

    if ($cachedData === false) {
        // Nog niet gecached: data genereren en cachen
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        // Zet cache met ttl 60 seconden
        $memcached->set($cacheKey, $cachedData, 60);
        $response->getBody()->write($cachedData);
    } else {
        // Gebruik cachedata
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

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

Toegang:https://servbay-slim-test.local/memcached-example. De eerste keer krijg je "This was not cached.", volgende keren tot de TTL verlopen is: "This was served from cache."

Redis Voorbeeld

ServBay bevat een Redis-pakket en de PHP-extensie ext-redis. Installeer een client-library, bijvoorbeeld predis/predis.

Installeer Redis-client: In de projectroot:
bash
```
composer require predis/predis
```
1

Voeg Redis-route toe in public/index.php: Voeg vóór $app->run(); deze code toe:

php

// ... eerdere initialisatie/database/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 een nieuwe Redis-client (ServBay default: 127.0.0.1:6379)
        $redis = new RedisClient([
            'scheme' => 'tcp',
            'host' => '127.0.0.1',
            'port' => 6379,
        ]);

        $cacheKey = 'my_servbay_redis_cache_key';
        // Probeer de cache uit te lezen
        $cachedData = $redis->get($cacheKey);

        if ($cachedData === null) {
            // Nog niet gecached: data genereren en cachen
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            // Zet cache met TTL 60 sec
            $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
            $response->getBody()->write($cachedData);
        } else {
            // Gebruik cache
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // Fout bij verbinden of operaties
        $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }


    return $response;
});

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

Toegang: Ga naar https://servbay-slim-test.local/redis-example. De eerste keer zie je "This was not cached.", bij volgende verzoeken tot de cache verloopt: "This was served from cache."

Samenvatting

Met bovenstaande stappen heb je succesvol een Slim Framework-project opgezet in de lokale ServBay-ontwikkelomgeving, de Website-functie van ServBay geconfigureerd en het project via een domein bereikbaar gemaakt. Je hebt geleerd hoe je diverse ServBay softwarepakketten (zoals MySQL, PostgreSQL, Memcached, Redis) en de benodigde PHP-extensies inzet om databases en caching te integreren in je Slim-applicatie. ServBay maakt het opzetten en beheren van een lokale ontwikkelomgeving simpel, zodat jij je volledig kunt richten op de ontwikkeling zelf.

Een Slim Project Aanmaken en Draaien in ServBay ​

Wat is Slim? ​

Belangrijkste Kenmerken en Voordelen van Slim ​

Een Slim Project Aanmaken en Draaien met ServBay ​

Vereisten ​

Een Slim Project Aanmaken ​

De Slim Applicatie Initialiseren ​

ServBay Website Configureren ​

Je Slim Site Benaderen ​

Voorbeelden van Database-integratie ​

Voorbereiding: Database Aanmaken en Migrations Draaien ​

Gebruik van het illuminate/database Component ​

MySQL Voorbeeld ​

PostgreSQL Voorbeeld ​

Memcached Voorbeeld ​

Redis Voorbeeld ​

Samenvatting ​