Het Pipeline-patroon

Wat is het pipelinepatroon?

Het pipelinepatroon is een designpattern waarbij een te verwerken object (de passable) achtereenvolgens door een reeks pipes (verwerkingsstappen) wordt geleid. Elke pipe ontvangt de uitvoer van de vorige stap, voegt bewerking toe en geeft het door aan de volgende stap. In Laravel implementeert de klasse Illuminate\Pipeline\Pipeline dit patroon, en de verwerking van middleware werkt precies volgens dit mechanisme.

Request → [Middleware 1] → [Middleware 2] → [Controller] → Response

Waar het in de Laravel-core wordt gebruikt

De pipeline wordt breed ingezet in de kern van Laravel.

HTTP-middleware — Illuminate\Foundation\Http\Kernel leidt de request door de middleware-pipeline
Consolecommando’s — voor- en nabewerking van Artisan-commando’s
Middleware van de router — het toepassen van middleware op routegroepen

Laten we kijken naar het deel waar de HTTP-kernel de pipeline gebruikt.

// Uit Illuminate\Foundation\Http\Kernel
protected function sendRequestThroughRouter($request)
{
    return (new Pipeline($this->app))
        ->send($request)
        ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
        ->then($this->dispatchToRouter());
}

Basisgebruik

send / through / thenReturn

De eenvoudigste opbouw van een pipeline.

use Illuminate\Pipeline\Pipeline;

$result = app(Pipeline::class)
    ->send('hello')
    ->through([
        function (string $passable, Closure $next): string {
            return $next(strtoupper($passable));
        },
        function (string $passable, Closure $next): string {
            return $next($passable . '!');
        },
    ])
    ->thenReturn();

// $result === 'HELLO!'

send($passable) — geeft het object op dat door de pipeline gaat
through($pipes) — geeft de array van pipes op
thenReturn() — voert de pipeline uit en geeft het resultaat terug

then

Wil je de laatste bewerking als closure opgeven, dan gebruik je then().

$result = app(Pipeline::class)
    ->send($request)
    ->through([AuthPipe::class, LogPipe::class])
    ->then(function ($request) {
        return 'processed: ' . $request;
    });

pipe

Om achteraf pipes toe te voegen, gebruik je pipe().

$pipeline = app(Pipeline::class)
    ->send($data)
    ->through([FirstPipe::class]);

// Afhankelijk van de voorwaarde een extra pipe invoegen
if ($needsExtra) {
    $pipeline->pipe(ExtraPipe::class);
}

$result = $pipeline->thenReturn();

Klassegebaseerde pipes

Door dedicated klassen te gebruiken in plaats van closures, verhoog je de herbruikbaarheid. Elke pipe-klasse implementeert een handle-methode.

namespace App\Pipes;

use Closure;

class TrimPipe
{
    public function handle(string $passable, Closure $next): string
    {
        return $next(trim($passable));
    }
}

namespace App\Pipes;

use Closure;

class SanitizePipe
{
    public function handle(string $passable, Closure $next): string
    {
        $sanitized = htmlspecialchars($passable, ENT_QUOTES, 'UTF-8');

        return $next($sanitized);
    }
}

use App\Pipes\TrimPipe;
use App\Pipes\SanitizePipe;
use Illuminate\Pipeline\Pipeline;

$result = app(Pipeline::class)
    ->send('  <script>alert("xss")</script>  ')
    ->through([TrimPipe::class, SanitizePipe::class])
    ->thenReturn();

// $result === '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'

via — de aan te roepen methode wijzigen

Standaard wordt de handle-methode van de pipe aangeroepen, maar met via() kun je een andere methodenaam opgeven.

class ValidatePipe
{
    public function process(array $data, Closure $next): array
    {
        // Validatielogica
        return $next($data);
    }
}

$result = app(Pipeline::class)
    ->send($data)
    ->through([ValidatePipe::class])
    ->via('process')
    ->thenReturn();

Parameters doorgeven aan pipes

Met : en , in de klassenaam kun je parameters aan een pipe doorgeven. Dit is hetzelfde mechanisme als de middleware-syntaxis zoals throttle:60,1.

namespace App\Pipes;

use Closure;

class LimitLengthPipe
{
    public function handle(string $passable, Closure $next, int $max = 100): string
    {
        return $next(substr($passable, 0, $max));
    }
}

$result = app(Pipeline::class)
    ->send($longText)
    ->through(['App\Pipes\LimitLengthPipe:50'])
    ->thenReturn();

finally — verwerking na afloop van de pipeline

Met de finally()-methode registreer je een callback die na afloop van de pipeline altijd wordt uitgevoerd — ongeacht succes of falen.

$result = app(Pipeline::class)
    ->send($request)
    ->through([LogPipe::class, AuthPipe::class])
    ->finally(function ($passable) {
        // Bijvoorbeeld loggen of resources vrijgeven
        logger()->info('Pipeline completed', ['request' => $passable]);
    })
    ->thenReturn();

withinTransaction — uitvoeren binnen een transactie

Sinds Laravel 11 kun je de hele pipeline binnen een databasetransactie uitvoeren.

$result = app(Pipeline::class)
    ->send($order)
    ->through([
        CreateOrderPipe::class,
        ChargePaymentPipe::class,
        SendConfirmationPipe::class,
    ])
    ->withinTransaction()
    ->thenReturn();

Je kunt ook een specifieke databaseverbinding opgeven.

->withinTransaction('mysql')

Als er in een van de pipes een exception optreedt, wordt de hele transactie teruggedraaid.

Praktijkvoorbeeld: een orderverwerkingspipeline

Een voorbeeld waarin de orderverwerking van een webshop uit meerdere pipes is opgebouwd.

Maak de pipe-klassen

namespace App\Pipes\Order;

use App\Models\Order;
use Closure;

class ValidateInventoryPipe
{
    public function handle(Order $order, Closure $next): Order
    {
        foreach ($order->items as $item) {
            if ($item->product->stock < $item->quantity) {
                throw new \RuntimeException("Onvoldoende voorraad: {$item->product->name}");
            }
        }

        return $next($order);
    }
}

namespace App\Pipes\Order;

use App\Models\Order;
use Closure;

class ReserveInventoryPipe
{
    public function handle(Order $order, Closure $next): Order
    {
        foreach ($order->items as $item) {
            $item->product->decrement('stock', $item->quantity);
        }

        return $next($order);
    }
}

namespace App\Pipes\Order;

use App\Models\Order;
use App\Services\PaymentService;
use Closure;

class ProcessPaymentPipe
{
    public function __construct(
        protected PaymentService $payment,
    ) {}

    public function handle(Order $order, Closure $next): Order
    {
        $this->payment->charge($order->total, $order->payment_token);
        $order->update(['status' => 'paid']);

        return $next($order);
    }
}

Voer de pipeline uit

use App\Models\Order;
use App\Pipes\Order\ValidateInventoryPipe;
use App\Pipes\Order\ReserveInventoryPipe;
use App\Pipes\Order\ProcessPaymentPipe;
use Illuminate\Pipeline\Pipeline;

class OrderService
{
    public function process(Order $order): Order
    {
        return app(Pipeline::class)
            ->send($order)
            ->through([
                ValidateInventoryPipe::class,
                ReserveInventoryPipe::class,
                ProcessPaymentPipe::class,
            ])
            ->withinTransaction()
            ->thenReturn();
    }
}

De interne implementatie van Pipeline

De carry()-methode is het hart van de pipeline. Met array_reduce worden de pipes van rechts naar links gevouwen tot een keten van closures.

// Binnen Pipeline::then()
protected function carry()
{
    return function ($stack, $pipe) {
        return function ($passable) use ($stack, $pipe) {
            if (is_callable($pipe)) {
                return $pipe($passable, $stack);
            } elseif (! is_object($pipe)) {
                [$name, $parameters] = $this->parsePipeString($pipe);
                $pipe = $this->getContainer()->make($name);
                $parameters = array_merge([$passable, $stack], $parameters);
            } else {
                $parameters = [$passable, $stack];
            }

            return $pipe->{$this->method}(...$parameters);
        };
    };
}

Door de pipes met array_reverse om te keren en aan array_reduce door te geven, blijft de aanroepvolgorde correct. De closure-stack wordt van binnen naar buiten opgebouwd, zodat de eerste pipe als eerste wordt uitgevoerd.

De pipeline wordt ook wel de “ui-architectuur” genoemd. De request gaat van de buitenste laag (de eerste pipe) naar binnen, en de response komt van binnen weer naar buiten. Daarom kan elke middleware zowel vóór als ná het aanroepen van $next() bewerkingen toevoegen.

Combineren met de Macroable-trait

Omdat de Pipeline-klasse de Macroable-trait gebruikt, kun je er eigen methodes aan toevoegen.

use Illuminate\Pipeline\Pipeline;

Pipeline::macro('sendThroughLogging', function (array $pipes) {
    /** @var Pipeline $this */
    return $this->through(array_map(function ($pipe) {
        return function ($passable, $next) use ($pipe) {
            logger()->debug("Entering pipe: {$pipe}");
            $result = $next($passable);
            logger()->debug("Exiting pipe: {$pipe}");
            return $result;
        };
    }, $pipes));
});

$result = app(Pipeline::class)
    ->send($data)
    ->sendThroughLogging([TrimPipe::class, SanitizePipe::class])
    ->thenReturn();

Volgende stap

Macroable-trait

Leer hoe je met de Macroable-trait eigen methodes toevoegt aan bestaande klassen.

AI-ontwikkeling

Design patterns

Package-ontwikkeling

Applicatiestructuur

Nieuwe functies in Laravel 13

Eloquent in detail

Validatie-uitbreidingen

Authenticatie uitbreiden

Beveiliging

Queues

Testen

Wat is het pipelinepatroon?

Waar het in de Laravel-core wordt gebruikt

Basisgebruik

send / through / thenReturn

then

pipe

Klassegebaseerde pipes

via — de aan te roepen methode wijzigen

Parameters doorgeven aan pipes

finally — verwerking na afloop van de pipeline

withinTransaction — uitvoeren binnen een transactie

Praktijkvoorbeeld: een orderverwerkingspipeline

De interne implementatie van Pipeline

Combineren met de Macroable-trait

Volgende stap

Macroable-trait

​Wat is het pipelinepatroon?

​Waar het in de Laravel-core wordt gebruikt

​Basisgebruik

​send / through / thenReturn

​then

​pipe

​Klassegebaseerde pipes

​via — de aan te roepen methode wijzigen

​Parameters doorgeven aan pipes

​finally — verwerking na afloop van de pipeline

​withinTransaction — uitvoeren binnen een transactie

​Praktijkvoorbeeld: een orderverwerkingspipeline

​De interne implementatie van Pipeline

​Combineren met de Macroable-trait

​Volgende stap

Macroable-trait

Wat is het pipelinepatroon?

Waar het in de Laravel-core wordt gebruikt

Basisgebruik

send / through / thenReturn

then

pipe

Klassegebaseerde pipes

via — de aan te roepen methode wijzigen

Parameters doorgeven aan pipes

finally — verwerking na afloop van de pipeline

withinTransaction — uitvoeren binnen een transactie

Praktijkvoorbeeld: een orderverwerkingspipeline

De interne implementatie van Pipeline

Combineren met de Macroable-trait

Volgende stap