DEV Community

Cover image for Utilisation des Pipelines pour structurer le flux de traitement en Laravel(Partie 1)
Dieudonne Gwet Bikoun
Dieudonne Gwet Bikoun

Posted on

Utilisation des Pipelines pour structurer le flux de traitement en Laravel(Partie 1)

Laravel regorge de fonctionnalités puissantes et souvent sous-exploitées. Parmi elles, les Pipelines (ou "tuyaux") offrent un moyen élégant de structurer des flux de traitement complexes en les découpant en étapes modulaires. Que vous traitiez des données, gériez des requêtes HTTP ou orchestriez des workflows métier, les Pipelines peuvent simplifier votre code et le rendre plus maintenable. Découvrons ensemble comment les utiliser !


Qu'est-ce qu'un Pipeline ?

Un Pipeline est un design pattern qui permet de faire passer un objet (une requête, une donnée, etc.) à travers une série d'étapes de traitement (pipes), chacune ayant une responsabilité unique. Chaque étape peut modifier l'objet ou déclencher une action avant de le transmettre à l'étape suivante.
C’est le même principe que les middleware, mais les Pipelines sont plus flexibles et s’appliquent à des cas d’usage bien plus variés.

Pourquoi utiliser les Pipelines ?

Modularité : Chaque étape est isolée et réutilisable.

Lisibilité : Le flux de traitement est clairement défini.

Maintenabilité : Ajouter ou retirer une étape est trivial.

Testabilité : Chaque pipe peut être testé unitairement.


Exemple Pratique : Modération de contenu

Imaginons que vous deviez implémenter un système de modération de contenu pour des articles. Le flux de traitement doit vérifier successivement :

Si le contenu contient du spam.
Si des mots interdits sont présents.
Si le formatage est correct.

Sans Pipeline, vous pourriez écrire :

$article = new Article($content);

// Étape 1 : Vérifier le spam
if ($spamChecker->isSpam($article)) {
    throw new SpamDetectedException();
}

// Étape 2 : Filtrer les mots interdits
$filteredContent = $wordFilter->filter($article->content);
$article->content = $filteredContent;

// Étape 3 : Formater le contenu
$formattedContent = $formatter->format($article->content);
$article->content = $formattedContent;

$article->save();
Enter fullscreen mode Exit fullscreen mode

Avec le pipeline, ca devient:

use Illuminate\Pipeline\Pipeline;

$article = new Article($content);

$processedArticle = app(Pipeline::class)
    ->send($article)
    ->through([
        CheckForSpam::class,
        FilterForbiddenWords::class,
        FormatContent::class,
    ])
    ->then(function ($article) {
        return $article->save();
    });
Enter fullscreen mode Exit fullscreen mode

Chaque étape est encapsulée dans une classe dédiée, ce qui rend le code plus clair et scalable.


Comment ça marche ?

Structure d'un Pipe

Chaque pipe doit implémenter une méthode handle($passable, $next) :

class CheckForSpam {
    public function handle($article, $next) {
        if (SpamChecker::detect($article->content)) {
            throw new SpamDetectedException();
        }
        return $next($article);
    }
}
Enter fullscreen mode Exit fullscreen mode
  • $passable : L'objet transmis dans le pipeline (ici, $article).

  • $next : La closure pour passer à l'étape suivante.


Cas d'Usage Avancés

1. Traitement des données en Batch

$data = collect([...]);

$processedData = app(Pipeline::class)
    ->send($data)
    ->through([
        NormalizeData::class,
        EnrichWithExternalAPI::class,
        ExportToCSV::class,
    ])
    ->thenReturn();
Enter fullscreen mode Exit fullscreen mode

2. Gestion de workflow metier

Exemple : Validation d'une commande en plusieurs étapes (stock, paiement, livraison).

app(Pipeline::class)
    ->send($order)
    ->through([
        ValidateStock::class,
        ProcessPayment::class,
        ScheduleDelivery::class,
    ])
    ->then(function ($order) {
        $order->markAsCompleted();
    });
Enter fullscreen mode Exit fullscreen mode

3. Personnalisation dynamique des étapes

Vous pouvez ajouter des étapes conditionnellement :

$pipes = [FilterForbiddenWords::class];

if ($user->isAdmin) {
    $pipes[] = ApplyAdminRules::class;
}

app(Pipeline::class)
    ->send($article)
    ->through($pipes)
    ->then(...);
Enter fullscreen mode Exit fullscreen mode

Bonnes Pratiques

Une responsabilité par pipe : Évitez les classes qui font trop de choses.

Utilisez des interfaces : Pour standardiser les pipes (ex: interface Pipe { handle(...); }).

Testez chaque étape : Des unit tests simples pour chaque pipe.

Documentez le flux : Liste des étapes et leur ordre dans la documentation.


Conclusion

Les Pipelines sont un outil puissant pour structurer des flux de traitement complexes tout en gardant un code propre et modulaire. Que ce soit pour de la modération de contenu, des ETL (Extract-Transform-Load) ou des workflows métier, ils apportent une solution élégante et scalable.
Laravel rend leur implémentation triviale grâce à la classe Illuminate\Pipeline\Pipeline – alors pourquoi ne pas en profiter ? 🚀


Et vous, avez-vous déjà utilisé les Pipelines dans vos projets ? Partagez vos retours en commentaire !
Si cet article vous a aidé, n’hésitez pas à le partager avec votre réseau. 👇

Image of Timescale

🚀 pgai Vectorizer: SQLAlchemy and LiteLLM Make Vector Search Simple

We built pgai Vectorizer to simplify embedding management for AI applications—without needing a separate database or complex infrastructure. Since launch, developers have created over 3,000 vectorizers on Timescale Cloud, with many more self-hosted.

Read more

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more