Stap-voor-stap je eigen RESTful API bouwen met PHP

Home » Tutorials » Stap-voor-stap je eigen RESTful API bouwen met PHP

Het ontwikkelen van een RESTful API kan een waardevolle vaardigheid zijn voor elke webontwikkelaar. Deze gids neemt je mee door de stappen om je eigen RESTful API te bouwen met PHP. We zullen beginnen met de basisprincipes en doorgaan tot het beveiligen, testen en documenteren van je API.

Wat is een RESTful API?

Een RESTful API (Representational State Transfer Application Programming Interface) is een interface die communicatie tussen verschillende softwaretoepassingen mogelijk maakt via HTTP-protocollen. Het biedt een gestandaardiseerde manier om gegevens te benaderen en te manipuleren, gebruikmakend van HTTP-methoden zoals GET, POST, PUT en DELETE.

Basisprincipes van REST

REST staat voor Representational State Transfer en is een architectonische stijl voor het ontwerpen van netwerktoepassingen. De basisprincipes van REST zijn:

  • Stateless: Elke API-aanroep moet alle benodigde informatie bevatten om de server te begrijpen en te verwerken.
  • Client-Server: De client en server zijn onafhankelijk van elkaar, waardoor ze afzonderlijk kunnen worden ontwikkeld en geschaald.
  • Cacheable: Responses moeten aangeven of ze cacheable zijn of niet, om de prestaties te verbeteren.
  • Uniform Interface: Er moet een gestandaardiseerde manier zijn om de API te benaderen, wat de eenvoud en schaalbaarheid bevordert.

Installatie en configuratie van PHP en relevante extensies

Om te beginnen met het bouwen van een RESTful API in PHP, moeten we zorgen voor een juiste installatie en configuratie van PHP en de benodigde extensies. Volg deze stappen:

  1. Download en installeer de nieuwste versie van PHP van de officiële PHP-website.
  2. Installeer een webserver zoals Apache of Nginx. Voor deze gids gebruiken we Apache.
  3. Controleer of de volgende PHP-extensies zijn geïnstalleerd en ingeschakeld: pdo_mysql, json, mbstring. Dit kun je doen door het php.ini-bestand te bewerken of de volgende opdracht uit te voeren: php -m.
  4. Start de webserver en zorg ervoor dat PHP correct is geïnstalleerd door een phpinfo()-bestand te maken en te openen in je browser.

Routes en controllers maken

Een belangrijk onderdeel van een RESTful API is het definiëren van routes en controllers. Routes bepalen welke URL-paden beschikbaar zijn, en controllers bevatten de logica voor het afhandelen van verzoeken.

Stap 1: Directorystructuur opzetten

Maak een directorystructuur aan voor je project:

    myapi/
    ├── public/
    │   └── index.php
    ├── src/
    │   ├── controllers/
    │   │   └── UserController.php
    │   ├── models/
    │   │   └── User.php
    │   └── routes/
    │       └── routes.php
    └── vendor/

Stap 2: Composer installeren

Gebruik Composer om autoloading te beheren en eventuele externe bibliotheken te installeren. Voer de volgende opdrachten uit:

    composer init
    composer require slim/slim "^4.0"

Stap 3: Routes definiëren

Maak een routes-bestand aan in src/routes/routes.php en definieer de routes voor je API:

    <?php
    use Slim\Factory\AppFactory;

    require __DIR__ . '/../../vendor/autoload.php';

    $app = AppFactory::create();

    $app->get('/users', \App\Controllers\UserController::class . ':getAllUsers');
    $app->get('/users/{id}', \App\Controllers\UserController::class . ':getUserById');
    $app->post('/users', \App\Controllers\UserController::class . ':createUser');
    $app->put('/users/{id}', \App\Controllers\UserController::class . ':updateUser');
    $app->delete('/users/{id}', \App\Controllers\UserController::class . ':deleteUser');

    $app->run();

CRUD operaties implementeren

De kern van een RESTful API is het uitvoeren van CRUD-operaties (Create, Read, Update, Delete). Laten we deze operaties implementeren in de UserController.

Stap 1: User model

Maak een eenvoudig User model in src/models/User.php:

    <?php
    namespace App\Models;

    class User {
        public $id;
        public $name;
        public $email;

        // Voeg hier constructor en methoden toe om gegevens te manipuleren
    }

Stap 2: UserController implementeren

Maak een UserController in src/controllers/UserController.php en implementeer de CRUD-methoden:

    <?php
    namespace App\Controllers;

    use Psr\Http\Message\ResponseInterface as Response;
    use Psr\Http\Message\ServerRequestInterface as Request;

    class UserController {
        private $users = [];

        public function __construct() {
            // Initialiseer met enkele dummy gegevens
            $this->users = [
                ['id' => 1, 'name' => 'John Doe', 'email' => 'john@example.com'],
                ['id' => 2, 'name' => 'Jane Smith', 'email' => 'jane@example.com'],
            ];
        }

        public function getAllUsers(Request $request, Response $response, $args) {
            $response->getBody()->write(json_encode($this->users));
            return $response->withHeader('Content-Type', 'application/json');
        }

        public function getUserById(Request $request, Response $response, $args) {
            $id = $args['id'];
            $user = array_filter($this->users, function($user) use ($id) {
                return $user['id'] == $id;
            });

            if (empty($user)) {
                return $response->withStatus(404);
            }

            $response->getBody()->write(json_encode(array_shift($user)));
            return $response->withHeader('Content-Type', 'application/json');
        }

        public function createUser(Request $request, Response $response, $args) {
            $data = $request->getParsedBody();
            $newUser = [
                'id' => count($this->users) + 1,
                'name' => $data['name'],
                'email' => $data['email']
            ];
            $this->users[] = $newUser;

            $response->getBody()->write(json_encode($newUser));
            return $response->withHeader('Content-Type', 'application/json')->withStatus(201);
        }

        public function updateUser(Request $request, Response $response, $args) {
            $id = $args['id'];
            $data = $request->getParsedBody();
            foreach ($this->users as &$user) {
                if ($user['id'] == $id) {
                    $user['name'] = $data['name'];
                    $user['email'] = $data['email'];
                    $response->getBody()->write(json_encode($user));
                    return $response->withHeader('Content-Type', 'application/json');
                }
            }

            return $response->withStatus(404);
        }

        public function deleteUser(Request $request, Response $response, $args) {
            $id = $args['id'];
            foreach ($this->users as $key => $user) {
                if ($user['id'] == $id) {
                    unset($this->users[$key]);
                    return $response->withStatus(204);
                }
            }

            return $response->withStatus(404);
        }
    }

Beveiliging van de API

Beveiliging is een cruciaal aspect van het bouwen van een API. Hier zijn enkele stappen om je API te beveiligen:

Authenticatie en Autorisatie

Implementeren van authenticatie en autorisatie is belangrijk om ervoor te zorgen dat alleen geautoriseerde gebruikers toegang hebben tot bepaalde delen van je API. Gebruik bijvoorbeeld JSON Web Tokens (JWT) om gebruikers te authenticeren.

    composer require firebase/php-jwt

Inputvalidatie

Zorg ervoor dat alle invoer van gebruikers wordt gevalideerd om beveiligingsproblemen zoals SQL-injectie te voorkomen.

CORS-beleid

Configureer je server om alleen verzoeken van vertrouwde domeinen toe te staan door een correct CORS-beleid (Cross-Origin Resource Sharing) te implementeren.

Testen en documenteren van de API

Het testen en documenteren van je API is essentieel om ervoor te zorgen dat deze correct werkt en gemakkelijk te gebruiken is door andere ontwikkelaars.

Testen

Gebruik tools zoals Postman of cURL om je API-endpoints te testen. Schrijf eenheden en integratietests om de betrouwbaarheid van je API te waarborgen.

Documenteren

Documenteer je API met behulp van tools zoals Swagger of Apiary. Dit helpt andere ontwikkelaars te begrijpen hoe ze je API kunnen gebruiken.