Analyse approfondie du pipeline Laravel (code)

Le contenu partagé avec vous dans cet article est une analyse approfondie (code) du pipeline Laravel. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Fondamentalement, vous pouvez utiliser les pipelines Laravel pour transmettre des objets dans plusieurs classes afin d'effectuer tout type de tâches basées sur des opérations en chaîne, et renvoyer les résultats finaux en une seule fois une fois que toutes les "tâches" sont terminées.

L'exemple le plus courant du fonctionnement de la gestion est son utilisation au sein des composants du framework lui-même. Ce dont je parle ici, c’est de « middleware ».

Le middleware fournit un mécanisme pratique pour filtrer les requêtes HTTP envoyées à votre application...

Voici un exemple de middleware de base :

<?php

namespace App\Http\Middleware;

use Closure;

class TestMiddleware
{
    /**
     * 处理请求
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        // 在这里加入你的代码

        return $next($request);
    }
}

Ces "middlewares" sont en fait des pipelines qui gèrent les tâches requises pour l’exécution en acceptant les requêtes entrantes. Ici, vous pouvez détecter si la requête actuellement acceptée est une requête HTTP, une requête JSON ou une authentification utilisateur, etc.

Si vous jetez un rapide coup d'œil à la classe IlluminateFoundationHttpKernel, vous verrez comment le middleware est exécuté dans l'objet Pipeline.

/**
  * 将请求传入到指定的 中间件/路由。

  * @param  \Illuminate\Http\Request  $request
  * @return \Illuminate\Http\Response
  */
protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);
    Facade::clearResolvedInstance('request');
    $this->bootstrap();
    return (new Pipeline($this->app))
                    ->send($request)
                    ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
    ->then($this->dispatchToRouter());
}

Vous pouvez le voir sur ce code : l'instance de pipeline envoie la requête à un ensemble de middleware et la distribue au routeur.

Ne vous inquiétez pas si ce code vous semble un peu déroutant. J'illustrerai ses concepts associés avec quelques exemples.

Travailler sur une classe qui nécessite d'exécuter plusieurs tâches

Considérez ce scénario. Nous devons créer un système de forum permettant aux utilisateurs de créer des sujets et de laisser des messages. Mais le client vous demande de supprimer automatiquement les balises lorsqu'elles sont créées ou modifiées.

Voici ce que vous devez faire :

1. Remplacer la balise de lien dans le texte.

2. Utilisez "*" pour remplacer les mots sensibles.

3. Supprimez les balises de script du texte.

Peut-être finirez-vous par créer des classes associées pour gérer ces "tâches".

$pipes = [
    RemoveBadWords::class
    ReplaceLinkTags::clas
    RemoveScriptTags::class
];

Ce que nous devons faire est de transmettre notre "contenu" à chaque tâche tour à tour, puis de transmettre les résultats du traitement de la tâche précédente à la tâche suivante. Nous pouvons utiliser des tuyaux pour gérer cette tâche.

public function create(Request $request)
{
    $pipes = [
        RemoveBadWords::class,
        ReplaceLinkTags::class,
        RemoveScriptTags::class
    ];

    $post = app(Pipeline::class)
    ->send($request)
    ->through($pipes)
    ->then(function ($content) {
        return Post::create(['content' => $content]);
    });

    // 返回响应
}

Chaque classe "tâche" doit définir une méthode "handle" pour gérer les fonctions. Peut-être que programmer en implémentant une interface est une bonne idée :

<?php

namespace App;

use Closure;

interface Pipe
{
    public function handle($content, Closure $next);
}

• Nommer est si difficile ¯_(ツ)_/¯*

<?php

namespace App;

use Closure;

class RemoveBadWords implements Pipe
{
    public function handle($content, Closure $next)
    {
        // 在这里处理任务，返回待更新的 **$content** 给到下一个管道任务。
        return  $next($content);
    }
}

La méthode utilisée pour gérer la tâche reçoit deux paramètres, le premier est un objet passable et le second est la fermeture vers laquelle l'objet sera redirigé après l'exécution du dernier pipeline.

Vous pouvez également personnaliser le nom de la méthode pour remplacer le nom de la méthode "handle". Ensuite, vous devez spécifier le nom de la méthode à utiliser par le pipeline, comme ceci :

app(Pipeline::class)
 ->send($content)
 ->through($pipes)
 ->via('customMethodName') // <---- 就是这个 :)
 ->then(function ($content) {
     return Post::create(['content' => $content]);
 });

Que se passe-t-il à la fin ? (Que se passe-t-il à la fin ?)

Que devrait-il se passer voici le commit Le contenu sera modifié par chaque $pipes et le contenu final renvoyé sera enregistré.

$post = app(Pipeline::class)
    ->send($request->all())
    ->through($pipes)
    ->then(function ($content) {
        return Post::create(['content' => $content]);
    });

Derniers mots

N'oubliez pas qu'il existe de nombreuses façons de traiter ce type de problème. La façon dont vous choisissez dépend de vous. Mais soyez heureux d'avoir la connaissance de cette nouvelle arme dans votre base de connaissances déjà intégrée lorsque vous en avez besoin.

J'espère que cet exemple pourra vous permettre de mieux comprendre les "Laravel Pipelines" et comment les utiliser.

Vous pouvez également consulter la documentation de l'API Laravel si vous souhaitez en savoir plus sur son fonctionnement.

Recommandations associées :

Créez vous-même un environnement de développement Laravel Docker méthodes

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!