Introduction

Pré-requis

Assurez-vous d'avoir installé PHP, Composer et le serveur web Apache httpd Nous allons commencer par l'installation de PHP et du serveur web Apache httpd:

# dnf -y install php php-cli mod_php httpd

N'oubliez pas de désactiver selinux et d'ouvrir le pare-feu

Préparation et installation

On doit créer le répertoire dans lequel va s'installer Slim ainsi que le code du site. Dans ce cas présent nous allons utiliser /opt/slim:

# mkdir /opt/slim

Nous allons ensuite créer un hôte virtuel pour Apache avec une réécriture d'url. Nous allons créer le fichier /etc/httpd/conf.d/slim.conf:

<VirtualHost *:80>
    DocumentRoot /opt/slim/public
    <Directory /opt/slim/public>
        Require all granted
        RewriteEngine on
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteCond %{REQUEST_FILENAME} !-d
        RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]
    </Directory>
</VirtualHost>

On poursuit avec l'installation de Slim:

# composer create-project slim/slim-skeleton:dev-master /opt/slim

A la question :

Do you want to remove the existing VCS (.git, .svn..) history? [Y,n]?

Vous pouvez répondre Y Il faut maintenant donner les droits à Apache:

# chown -R apache. /opt/slim

Une fois le serveur Apache (re)démarré, vous devriez avoir le message Hello World!

Première utilisation

Arborescence

L'installation de Slim a créé plusieurs répertoires dont la plupart servent pour l'application exemple "Hello World":

/opt/slim
|_app
     \
      |_dependencies.php
      |_middleware.php
      |_repositories.php
      |_routes.php
      |_settings.php
|_logs
     \...
|_public
     \
      |_index.php
      |_...
|_src
     \...
|_tests
     \...
|_var
     \...
|_vendor
     \...
|_README.md
|_composer.json
|_phpunit.xml
|_composer.json

Vous pouvez avoir plus ou moins de répertoires, les plus importants sont les suivants:

app : contient les fichiers descriptifs de l'application
src : répertoire où nous allons stocker notre code source
composer.json : fichier qui va nous servir pour l'autoloader

Pour partir sur une base simple, vous pouvez supprimer (sauvegarder si besoin) le contenu des répertoires app et src

Chargement automatique du code

Le chargement automatique ou autoloading se fait grâce à composer dans le fichier composer .json. Repérez la section commençant par autoload:

"autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },

Cette section indique à composer que toutes les classes faisant partie de l'espace de nom App se trouvent dans le répertoire src. Nous allons modifier cette espace de nom pour le remplacer par tala (généralement le nom du projet ou de l'entreprise):

"autoload": {
        "psr-4": {
            "Tala\\": "src/"
        }
    },

Pour que la modification soit effective, il faut demander à composer de regénérer les fichiers de classes:

# cd /opt/slim
# composer du
Generating autoload files
Generated autoload files

Création de classes

Nous allons créer une petite api qui permet de lister des utilisateurs.

Dans le répertoire src nous allons créer les fichiers suivants:

User.php

<?php

namespace Tala;

class User
{

    public $name, $id;

    /**
     * User constructor.
     * @param $name
     * @param $id
     */
    public function __construct($name, $id)
    {
        $this->name = $name;
        $this->id = $id;
    }

}

UserDao.php

<?php

namespace Tala;

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

use Tala\User as User;

class UserDao
{
    // tableau contenant les utilisateurs
    private $users = array();

    public function __construct()
    {
        // Ajout d'utilisateurs pour faire les tests
        $this->users[] = new User("tala", 1);
        $this->users[] = new User("jcf", 2);
    }

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

    public function getUserById(Request $request, Response $response, array $args): Response
    {
        $id = $args['id'];
        foreach ($this->users as $user){
            if($user->id == $id){
                // Utilisateur trouvé, on retourne un 200
                $response->getBody()->write(json_encode($user));
                return $response->withHeader('Content-Type', 'application/json')->withStatus(200);
            }
        }
        // Utilisateur non trouvé on retourne un 404
        return $response->withStatus(404);
    }

}

Ajout d'une route

Dans le répertoire app nous allons créer un fichier routes.php qui va contenir le code suivant:

<?php

declare(strict_types=1);

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\App;
use Slim\Interfaces\RouteCollectorProxyInterface as Group;

return function (App $app) {
    $app->options('/{routes:.*}', function (Request $request, Response $response) {
        // CORS Pre-Flight OPTIONS Request Handler
        return $response;
    });

    $app->group('/users', function (Group $group) {
        // Route par défaut qui liste tous les utilisateurs
        $group->get('', \Tala\UserDao::class . ':getUsers');
        // Route qui permet de lister un utilisateur grâce à son identifiant
        $group->get('/{id}', \Tala\UserDao::class . ':getUserById');
    });
};

Déclaration dans la page d'index

Il ne reste plus qu'a définir tout ça dans le fichier index.php du répertoire public:

<?php

use Slim\Factory\AppFactory;

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

// Création de l'application Slim
$app = AppFactory::create();

// Enregistrement des routes
$routes = require __DIR__ . '/../app/routes.php';
$routes($app);

$app->run();

Utilisation

Nous avons déclaré deux points de terminaisons ou endpoint dans notre api :

/users : pour lister tous les utilisateurs
/users/{id} : pour afficher un utilisateur en fonction de son identifiant

Php slim

Sommaire