PHP Master | Travailler avec un middleware mince

Slim Framework Middleware: Construire des applications de micro PHP puissantes

Slim est un puissant Mini Framework PHP, où les fonctionnalités du middleware permettent la mise en œuvre de divers services de style filtre tels que l'authentification et la mise en cache dans les applications. Le middleware résume les applications et peut affecter l'environnement de l'application ainsi que les objets de demande et de réponse.

Points clés:

• Le middleware de Slim est une fonctionnalité puissante qui permet la mise en œuvre de divers services de style filtre tels que l'authentification et la mise en cache. Le middleware résume les applications et peut affecter l'environnement, la demande et la réponse des objets de l'application.
• Pour implémenter middleware dans Slim, vous devez écrire une classe qui étend la classe SlimMiddleware et remplacer la méthode call(). Cette méthode est le point d'entrée du middleware, à partir duquel vous pouvez retourner (interrompre le processus d'exécution) ou appeler la couche suivante. Le middleware peut ensuite manipuler l'en-tête et le corps de la réponse.
• Utilisez la méthode Slim add() pour enregistrer le middleware dans l'application SLIM. Plusieurs middleware peuvent être enregistrés par des appels ultérieurs à la méthode add(). Le middleware doit être ajouté dans l'ordre opposé de l'ordre des appels, car le nouveau middleware entourera tout middleware précédemment ajouté. La configuration du middleware est généralement effectuée via le constructeur de services.

Compréhension du middleware mince

La documentation mince compare l'application mince aux oignons, chaque couche de l'oignon est middleware. Il s'agit d'une métaphore appropriée. Pour mieux le comprendre, supposons que nous écrivons une application qui utilise l'authentification et la mise en cache. Notre architecture peut ressembler à ceci:

Le code responsable de la génération du contenu de la page est enveloppé dans plusieurs couches de middleware, dont les plus importantes sont la logique d'authentification et la logique de cache. Le processus d'exécution passe par chaque couche, permettant le flux vers la couche suivante ou le transfert. Vérifiez d'abord si l'utilisateur a passé l'authentification. Sinon, le processus est interrompu et l'état HTTP 401 est renvoyé. Vérifiez ensuite si une copie en cache du contenu peut être utilisée. Si c'est le cas, le processus est interrompu à l'aide de la copie en cache de la page. Il peut y avoir d'autres couches de middleware jusqu'à ce que le processus atteigne enfin la logique responsable de la génération de la page. Lorsque nos méthodes de middleware reviendront, le processus d'exécution bouillonnera à travers eux. Par exemple, le reste de la logique du middleware de cache mettra en cache le contenu de la page pour les recherches ultérieures.

Implémentation du middleware

Pour comprendre comment implémenter des middleware personnalisés, jetons un coup d'œil au code qui peut être utilisé comme middleware de cache mentionné ci-dessus. Il y a en fait très peu d'exigences pour implémenter tout composant de base middleware Slim. Nous avons juste besoin d'écrire une classe qui étend la classe SlimMiddleware et remplacer la méthode call(). Le point d'entrée du middleware est cette méthode call(), à partir de laquelle nous pouvons retourner (et donc interrompre le processus d'exécution) ou appeler la couche suivante.

<?php namespace MyMiddleware;

class Cache extends SlimMiddleware
{
    protected $db;

    public function __construct(PDO $db)
    {
        $this->db = $db;
    }

    public function call()
    {
        $key = $this->app->request()->getResourceUri();
        $rsp = $this->app->response();

        $data = $this->fetch($key);
        if ($data) {
            // 缓存命中...返回缓存的内容
            $rsp["Content-Type"] = $data["content_type"];
            $rsp->body($data["body"]);
            return;
        }

        // 缓存未命中...继续生成页面
        $this->next->call();

        if ($rsp->status() == 200) {
            // 缓存结果以供将来查找
            $this->save($key, $rsp["Content-Type"], $rsp->body());
        }
    }

    protected function fetch($key)
    {
        $query = "SELECT content_type, body FROM cache
            WHERE key = " . $this->db->quote($key);
        $result = $this->db->query($query);
        $row = $result->fetch(PDO::FETCH_ASSOC);
        $result->closeCursor();
        return $row;
    }

    protected function save($key, $contentType, $body)
    {
        $query = sprintf("INSERT INTO cache (key, content_type, body)
            VALUES (%s, %s, %s)",
            $this->db->quote($key),
            $this->db->quote($contentType),
            $this->db->quote($body)
        );
        $this->db->query($query);
    }

}

call() Méthode Vérifiez d'abord si le contenu est disponible dans le cache. Dans l'affirmative, il définit l'en-tête et le corps de la réponse Content-Type, puis revient, en court-circuit ainsi le pipeline. Si le cache manque, appelez $this->next->call() pour appeler la couche middleware suivante. Lorsque le processus revient à ce point à partir d'autres appels de middleware, l'état de la demande est rapidement vérifié et les données pertinentes sont mises en cache pour les recherches futures. Étant donné que cette classe étend la classe Middleware de Slim, elle peut accéder aux instances de l'application SLIM via $this->app, accédant ainsi indirectement à des objets de réponse et de demande. Nous pouvons influencer l'en-tête de la réponse en le traitant comme un tableau et influencer le corps de la réponse à travers sa méthode body(). Les méthodes fetch() et save() sont des méthodes d'assistance protégées, elles enveloppent simplement les requêtes de base de données pour trouver et persister du contenu. Je les ai inclus ici juste pour compléter les exemples. Il suppose qu'il existe un tableau nommé cache avec des colonnes key, content_type et body. Selon vos besoins, votre mécanisme de persistance peut varier. De plus, le cache expiré (pour la simplicité) n'est pas montré ici, bien que vous puissiez facilement le fusionner vous-même.

Enregistrement et configuration du middleware

Enregistrer le middleware à l'aide de la méthode add() de Slim.

<?php require_once "../vendor/autoload.php";

$app = new SlimSlim();
$app->add(new MyMiddlewareCache($db));

Bien sûr, plusieurs middleware peuvent être enregistrés via la méthode d'appel suivante add(). Étant donné que le nouveau middleware entourera tout middleware précédemment ajouté, cela signifie qu'ils doivent être ajoutés dans l'ordre opposé de l'appel.

<?php $app = new SlimSlim();
$app->add(new MyMiddlewareCache($db));
$app->add(new MyMiddlewareAuth($db));
// ...

Dans l'exemple ci-dessus, le middleware Cache enveloppe l'application SLIM, puis le middleware Auth enveloppe le Cache. Lorsque $app->run() est appelé, le processus d'exécution sera similaire à celui illustré dans la figure ci-dessus, entrant d'abord dans le middleware d'authentification, puis fonctionnant jusqu'au itinéraire. La configuration du middleware est généralement effectuée via le constructeur de services. Dans notre exemple, je passe simplement une connexion de base de données active afin qu'il puisse accéder à la table en cache, mais vous pouvez écrire votre classe pour accepter toute information dont vous pourriez avoir besoin pour personnaliser son comportement. Par exemple, le composant peut être remplacé pour accepter un objet de gestionnaire qui expose les méthodes fetch() et save(); Fournissez des fonctionnalités dans le cadre de la configuration des composants.

Conclusion

J'ai trouvé que le middleware est une solution élégante pour implémenter tous les aspects des applications minces. Dans cet article, j'explique comment fonctionne l'architecture de middleware et ce qu'il faut pour implémenter votre propre middleware. Il existe un petit référentiel supplémentaire avec quelques exemples de middleware de base tels que la protection CSRF et l'authentification HTTP. J'ai refactorisé l'exemple ici et soumis une demande de traction, donc si vous avez écrit un service middleware utile, pourquoi ne pas envisager de le soumettre à votre projet afin que d'autres puissent également en bénéficier?

(image de Fotolia)

(Ce qui suit est la FAQ, qui a été ajustée et complétée en fonction du contenu d'origine, et un contenu en double a été rationalisé)

FAQ sur middleware midle

• Qu'est-ce que le middleware mince et pourquoi est-il important? Slim Middleware est un outil puissant dans le framework Slim qui vous permet de manipuler les demandes et les réponses HTTP. Il est important car il fournit un moyen d'exécuter du code avant et après l'application mince pour modifier les demandes entrantes ou les réponses sortantes. Cela peut être utilisé à diverses fins telles que l'authentification, la mise en cache ou la journalisation.

• Comment créer du middleware dans Slim? La création d'un middleware dans SLIM implique de définir une classe qui implémente MiddlewareInterface. Cette classe doit avoir une méthode appelée process() qui reçoit ServerRequestInterface et RequestHandlerInterface. La méthode process() est l'endroit où vous pouvez manipuler les demandes et les réponses.

• Comment ajouter du middleware à mon application mince? Vous pouvez utiliser la méthode add() pour ajouter du middleware à votre application mince. Cette méthode reçoit une instance de la classe de middleware. Le middleware est exécuté dans l'ordre d'addition, de sorte que le dernier middleware ajouté sera le premier middleware à exécuter.

• Puis-je utiliser du middleware pour des itinéraires spécifiques dans SLIM? Oui, le middleware peut être appliqué à des itinéraires spécifiques dans SLIM. Cela se fait en appelant la méthode Route sur l'objet App au lieu de l'objet add(). Cela vous permet d'avoir un middleware qui n'affecte que certains itinéraires.

• Quelle est la différence entre le middleware global et le middleware de routage? Le middleware global est appliqué à chaque demande traitée par l'application SLIM, tandis que le middleware de routage est appliqué à uniquement des itinéraires spécifiques. Cela vous permet d'utiliser différents middleware pour différentes parties de votre application.

• Comment utiliser le middleware pour effectuer la gestion des erreurs dans SLIM? En attrapant des exceptions dans la classe de middleware, vous pouvez utiliser le middleware pour effectuer une gestion des erreurs dans Slim. Vous pouvez ensuite modifier la réponse pour inclure un message d'erreur ou rediriger l'utilisateur vers la page d'erreur.

• Pouvez-vous authentifier les utilisateurs en middleware? Oui, le middleware est souvent utilisé pour l'authentification dans Slim. Cela peut être fait en vérifiant une session ou un jeton valide dans le middleware et renvoie une réponse d'erreur si l'utilisateur n'est pas authentifié.

• Comment utiliser le middleware pour se connecter mince? En écrivant des informations sur les demandes et les réponses à un fichier journal, le middleware peut être utilisé pour la journalisation. Ceci est très utile pour déboguer ou surveiller votre application.

• Puis-je utiliser du middleware tiers avec Slim? Oui, Slim prend en charge le middleware tiers. Cela peut être ajouté à votre application comme votre propre middleware. Cela vous permet de tirer parti des middleware existants pour effectuer des tâches courantes.

• Comment tester mon middleware mince? Tester Slim Middleware consiste à créer des demandes et des réponses simulées et à les transmettre à votre middleware. Vous pouvez ensuite affirmer que le middleware se comporte comme prévu, comme modifier une demande ou une réponse, ou lancer une exception.

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!