Introduction au middleware

Qu’est-ce qu’un middleware ?

Le middleware est un modèle de conception logicielle qui permet une communication et un échange de données transparents entre différents systèmes, applications ou services. Il joue un rôle crucial en facilitant les interactions entre des composants disparates, en ajoutant des fonctionnalités et en améliorant les performances globales du système.

Le problème

Dans notre projet précédent, nous avons rencontré un problème où un utilisateur connecté était invité à se réinscrire lors de sa visite sur la page d'inscription. Cela était dû au manque de mise en œuvre d'un middleware, ce qui entraînait une mauvaise expérience utilisateur.

Intergiciel en PHP

En PHP, le middleware peut être utilisé pour gérer les fonctionnalités d'enregistrement et de connexion des utilisateurs, garantissant ainsi une expérience utilisateur fluide. Le middleware agit comme un pont entre les différents composants, permettant une communication et un échange de données transparents.

if ($_SESSION['user'] ?? false){ 
    header('location: /'); 
    exit(); 
}

Il vérifie si l'utilisateur est connecté ou non. Sinon, quittez le script pour trouver un utilisateur authentifié.

Configuration de l'itinéraire

Dans le fichier routes.php, on peut ajouter une clé 'guest' à la route pour l'associer au middleware :

$router->get('/register', 'controllers/registration/create.php')->only('guest');

Débogage de la seule méthode

Pour vérifier si le projet fonctionne comme prévu, vous pouvez ajouter une instruction de débogage dans la seule méthode :

public function only($key){ 
    dd($key); 
}

Il affiche une erreur car la seule méthode ne peut pas fonctionner avec une valeur nulle car elle est associée à la méthode get et elle ne renvoie aucune valeur. Il faut donc réécrire la méthode.

Réécriture de la méthode Add

Pour renvoyer toutes les valeurs à la seule méthode, nous devons réécrire la méthode add dans le fichier router.php comme :

public function add($method, $uri, $controller) 
{ 
    $this->routes[] = [ 
        'uri' => $uri, 
        'controller' => $controller, 
        'method' => $method, 
        'middleware'=>null 
    ]; 
    return $this; 
}

Maintenant, nous pouvons voir que le projet fonctionne bien.

Seule méthode

La seule méthode du fichier router.php doit être modifiée pour accepter la clé middleware :

public function only($key){ 
    $this->routes[array_key_last($this->routes)]['middleware']=$key; 
    return $this; 
}

Vérification du middleware

Dans le fichier create.php, nous pouvons vérifier si l'utilisateur est connecté ou un invité utilisant le middleware :

if ($route['middleware']==='guest'){ 
    if($_SESSION['user'] ?? false){ 
        header('location: /'); 
        exit(); 
    } 
} 
if ($route['middleware']==='auth'){ 
    if(! $_SESSION['user'] ?? false){ 
        header('location: /'); 
        exit(); 
    } 
}

Seul l'utilisateur authentifié peut avoir accès à toutes les pages tandis que l'invité peut accéder aux seules pages limitées.

Création d'un répertoire middleware

Pour organiser nos classes middleware, créez un nouveau répertoire dans le dossier principal nommé Middleware. Comme nous devons faire des changements à un moment donné pour notre détente, pour économiser nos efforts et notre temps. Nous pouvons ainsi rendre notre projet plus facile à comprendre. Dans cela, créez 3 classes différentes.

Middleware d'authentification

Le fichier Authenticated.php vérifie si l'utilisateur est connecté et redirige vers la page d'accueil si vrai :

<?php namespace Core\Middleware; 
class Authenticated { 
    public function handle() { 
        if (! $_SESSION['user'] ?? false) { 
            header('location: /'); 
            exit(); 
        } 
    } 
}

Intergiciel invité

Le fichier Guest.php vérifie si l'utilisateur n'est pas connecté et redirige vers la page d'accueil si vrai :

<?php namespace Core\Middleware; 
class Guest { 
    public function handle() { 
        if ($_SESSION['user'] ?? false) { 
            header('location: /'); 
            exit(); 
        } 
    } 
}

Classe de middleware

Le fichier Middleware.php utilise une constante MAP pour mapper les clés du middleware à leurs classes respectives. Vérifie également si le middleware existe ou non. Sinon, affichez une exception non interceptée à l'utilisateur pour ajouter un middleware dans le projet :

<?php namespace Core\Middleware; 
class Middleware { 
    public const MAP = [ 
        'guest' => Guest::class, 
        'auth' => Authenticated::class 
    ]; 
    public static function resolve($key) { 
        if (!$key) { 
            return; 
        } 
        $middleware = static::MAP[$key] ?? false; 
        if (!$middleware) { 
            throw new \Exception("No matching middleware found for key '{$key}'."); 
        } 
        (new $middleware)->handle(); 
    } 
}

Maintenant, nous pouvons voir qu'en apportant ces changements, notre projet fonctionne bien.

J'espère que vous l'avez bien compris.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!