Découvrez Pipeline dans Laravel dans un article

Cet article vous amènera à comprendre le pipeline dans Laravel et à parler du paradigme de conception de pipeline. J'espère qu'il vous sera utile !

En général, en utilisant des tuyaux dans Laravel, vous pouvez passer en douceur un objet entre plusieurs classes pour effectuer n'importe quel type de tâche, une fois toutes les tâches exécutées, renvoyez la valeur du résultat.

Ensuite, vous pourrez en savoir plus sur les pipelines Laravel.

Concernant le fonctionnement des pipelines, l'exemple le plus évident est en fait l'un des composants les plus couramment utilisés dans le framework lui-même. Oui, je parle du middleware.

Le middleware fournit un mécanisme pratique pour filtrer les requêtes HTTP entrant dans votre application.

Un middleware de base devrait ressembler à ceci :

<?php
namespace App\Http\Middleware;
use Closure;
class TestMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        // Here you can add your code
        return $next($request);
    }
}

Ces "middleware" sont en fait des pipelines, à travers lesquels les requêtes sont envoyées pour effectuer toutes les tâches requises. Ici, vous pouvez vérifier si la requête est une requête HTTP, s'il s'agit d'une requête JSON, s'il existe des informations utilisateur authentifiées, etc.

Si vous souhaitez jeter un coup d'œil rapide à la classe IlluminateFoundationHttpKernel, vous verrez comment utiliser une nouvelle instance de la classe Pipeline pour exécuter un middleware. IlluminateFoundationHttpKernel 类, 你将看到如何使用 Pipeline 类的新实例来执行中间件。

/**
  * Send the given request through the middleware / router.
  *
  * @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());
}

你可以在代码中看到类似的内容：通过中间件列表发送请求的新管道，然后发送路由。

如果这让你看起来有点不知所措也不用担心。让我们试着用以下这个例子来阐明这个概念。

处理多任务运行类

让我们来看一种场景。 比方说，你建立了一个人们可以发帖并发表评论的论坛。但是，您的用户请求您自动删除标签或在创建时在每一个内容上编辑标签。

此时你被要求做的事情如下：

• 用纯文本替换链接标记；

• 用“*”替换敏感词；

• 从内容中完全删除脚本标记。

可能你最终会创建类来处理这些 “tasks”。

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

我们要做的是将给定的“内容”传递给每个任务，然后将结果返回给下一个任务。我们可以使用pipeline来做到这一点。

<?php

public function create(Request $request)
{
    $pipes = [
        RemoveBadWords::class,
        ReplaceLinkTags::class,
        RemoveScriptTags::class
    ];
    $post = app(Pipeline::class)
        ->send($request->content)
        ->through($pipes)
        ->then(function ($content) {
            return Post::create([&#39;content&#39; => &#39;content&#39;]);
        });
    // return any type of response
}

每个“task”类应该有一个“handle”方法来执行操作。也许每个类都有统一的约束是一个不错的选择:

<?php

namespace App;

use Closure;

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

命名是个困难的事情 ¯_(ツ)_/¯

<?php

namespace App;

use Closure;

class RemoveBadWords implements Pipe
{
    public function handle($content, Closure $next)
    {
        // Here you perform the task and return the updated $content
        // to the next pipe
        return  $next($content);
    }
}

用于执行任务的方法应该接收两个参数，第一个参数是合格的对象，第二个参数是当前操作处理完后会接管的下一个闭包（匿名函数）。

您可以使用自定义方法名称而不是“handle”。然后你需要指定pipeline要使用的方法名称，比如：

app(Pipeline::class)
 ->send($content)
 ->through($pipes)
 ->via(&#39;customMethodName&#39;) // <---- This one :)
 ->then(function ($content) {
     return Post::create([&#39;content&#39; => $content]);
 });

最后产生的效果是什么 ?

提交的内容将会被各个$pipes

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

Vous pouvez voir quelque chose comme ceci dans le code : un nouveau tube qui envoie la requête via une liste de middlewares puis envoie la route.

Ne vous inquiétez pas si cela vous semble un peu insurmontable. Essayons de clarifier ce concept à l'aide de l'exemple suivant.

Gestion d'un cours de course multitâche

Jetons un coup d'oeil genre de scène. Disons que vous créez un forum où les gens peuvent publier et commenter. Cependant, vos utilisateurs vous demandent de supprimer ou de modifier automatiquement les balises sur chaque élément de contenu au fur et à mesure de leur création.

Ce qui vous est demandé de faire à ce stade est le suivant :

• Remplacez la balise de lien par du texte brut

• Utilisez " *" Remplacez les mots sensibles ;

Supprimez complètement les balises de script du contenu.

Peut-être finirez-vous par créer des classes pour gérer ces « tâches ». rrreee

Ce que nous voulons faire, c'est transmettre le "contenu" donné à chaque tâche, puis renvoyer le résultat à la tâche suivante. Nous pouvons utiliser un pipeline pour ce faire. 🎜rrreee🎜Chaque classe "tâche" doit avoir une méthode "handle" pour effectuer des opérations. Ce serait peut-être un bon choix d'avoir des contraintes unifiées pour chaque classe : 🎜rrreee🎜🎜🎜Nommer est une chose difficile ¯_(ツ)_/¯🎜🎜🎜rrreee🎜La méthode utilisée pour effectuer la tâche doit recevoir deux paramètres, Le premier paramètre est l'objet qualifié et le deuxième paramètre est la prochaine fermeture (fonction anonyme) qui sera prise en charge après le traitement de l'opération en cours. 🎜🎜Vous pouvez utiliser un nom de méthode personnalisé au lieu de « handle ». Ensuite, vous devez spécifier le nom de la méthode à utiliser par le pipeline, tel que :🎜rrreee

🎜Quel est l'effet final ?🎜🎜🎜 Le contenu soumis sera traité par chaque $pipes, et les résultats traités seront stockés. 🎜rrreee🎜🎜🎜Epilogue🎜🎜🎜🎜N'oubliez pas qu'il existe de nombreuses façons de résoudre ce type de problème. Quant à la manière de choisir, cela dépend de votre propre choix. Sachez simplement que vous pouvez utiliser cet outil en cas de besoin. J'espère que cet exemple vous a permis de mieux comprendre les « pipelines Laravel » et comment les utiliser. Si vous souhaitez en savoir ou en savoir plus, vous pouvez consulter la documentation de l'API de Laravel🎜laravel.com/api/5.4/Illuminate/Pip...🎜🎜🎜🎜Adresse originale : https://medium.com/@jeffochoa/understanding -laravel-pipelines-a7191f75c351🎜🎜Adresse de traduction : https://learnku.com/laravel/t/7543/pipeline-pipeline-design-paradigm-in-laravel🎜🎜🎜[Recommandations associées : 🎜tutoriel vidéo laravel🎜]🎜

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!