Middleware

Erläutert, wie Sie mit Laravel-Middleware HTTP-Anfragen filtern und vorverarbeiten.

​

Was ist Middleware

Middleware ist ein Mechanismus, mit dem eingehende HTTP-Anfragen geprüft und gefiltert werden. Sie können Logik vor und nach dem Controller einschieben.

Beispielsweise enthält Laravel eine Authentifizierungs-Middleware. Ist der Nutzer nicht angemeldet, leitet sie zur Login-Seite um; ist er angemeldet, wird die Anfrage in die Anwendung weitergegeben.

Neben Authentifizierung sind Middleware ideal für Logging, CSRF-Schutz, Rate Limiting und vieles mehr. Details zum CSRF-Schutz in Laravel 13 finden Sie unter CSRF-Schutz.

Ihre eigenen Middleware legen Sie üblicherweise unter app/Http/Middleware ab.

​

Mitgelieferte Middleware

Laravel bringt standardmäßig zwei Middleware-Gruppen mit: web und api. Die Gruppe web wird auf routes/web.php, api auf routes/api.php angewendet.

Middleware-Gruppe web
EncryptCookies
AddQueuedCookiesToResponse
StartSession
ShareErrorsFromSession
PreventRequestForgery (CSRF-Schutz)
SubstituteBindings

Häufig verwendete Middleware sind über Aliase mit kurzen Namen ansprechbar.

Alias	Middleware
auth	Illuminate\Auth\Middleware\Authenticate
guest	Illuminate\Auth\Middleware\RedirectIfAuthenticated
verified	Illuminate\Auth\Middleware\EnsureEmailIsVerified
throttle	Illuminate\Routing\Middleware\ThrottleRequests

​

Middleware erstellen

Neue Middleware erzeugen Sie mit make:middleware.

php artisan make:middleware EnsureTokenIsValid

Es entsteht die Datei app/Http/Middleware/EnsureTokenIsValid.php. Die Verarbeitungslogik schreiben Sie in die Methode handle.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureTokenIsValid
{
    /**
     * Eingehenden Request verarbeiten
     *
     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
     */
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->input('token') !== 'my-secret-token') {
            return redirect('/home');
        }

        return $next($request);
    }
}

Der Aufruf von $next($request) reicht die Anfrage an die nächste Ebene weiter. Trifft eine Bedingung nicht zu, geben Sie einen Redirect oder eine andere Antwort zurück, um die Kette zu stoppen.

​

Vor- und Nachverarbeitung

Middleware kann vor oder nach dem Request Logik ausführen.

// Vor dem Request
public function handle(Request $request, Closure $next): Response
{
    // Vorverarbeitung hier

    return $next($request);
}

// Nach der Response
public function handle(Request $request, Closure $next): Response
{
    $response = $next($request);

    // Nachverarbeitung hier

    return $response;
}

​

Middleware registrieren

​

Globale Middleware

Um Middleware auf alle Anfragen anzuwenden, ergänzen Sie sie in bootstrap/app.php über withMiddleware im globalen Stack.

// bootstrap/app.php
use App\Http\Middleware\EnsureTokenIsValid;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->append(EnsureTokenIsValid::class);
    });

append fügt am Ende des Stacks hinzu, prepend am Anfang.

​

Middleware auf Routen anwenden

Für einzelne Routen rufen Sie in der Definition die Methode middleware auf.

use App\Http\Middleware\EnsureTokenIsValid;

Route::get('/profile', function () {
    // ...
})->middleware(EnsureTokenIsValid::class);

Mehrere Middleware übergeben Sie als Array.

Route::get('/', function () {
    // ...
})->middleware([First::class, Second::class]);

Zum Ausschluss einer Middleware auf einer bestimmten Route dient withoutMiddleware.

use App\Http\Middleware\EnsureTokenIsValid;

Route::middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/', function () {
        // Middleware wird angewendet
    });

    Route::get('/profile', function () {
        // Middleware ausgeschlossen
    })->withoutMiddleware([EnsureTokenIsValid::class]);
});

​

Middleware-Aliase

Für lange Klassennamen können Sie Aliase definieren – in bootstrap/app.php.

// bootstrap/app.php
use App\Http\Middleware\EnsureUserIsSubscribed;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->alias([
            'subscribed' => EnsureUserIsSubscribed::class,
        ]);
    });

Und in Routen verwenden:

Route::get('/profile', function () {
    // ...
})->middleware('subscribed');

​

Middleware-Gruppen

Mehrere Middleware können unter einem Schlüssel gebündelt werden. Dazu verwenden Sie appendToGroup oder prependToGroup in bootstrap/app.php.

// bootstrap/app.php
use App\Http\Middleware\First;
use App\Http\Middleware\Second;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->appendToGroup('group-name', [
            First::class,
            Second::class,
        ]);
    });

Gruppen wenden Sie wie einzelne Middleware auf Routen an.

Route::get('/', function () {
    // ...
})->middleware('group-name');

Route::middleware(['group-name'])->group(function () {
    // ...
});

Für die vorhandenen Gruppen web und api stehen eigene Methoden bereit.

// bootstrap/app.php
use App\Http\Middleware\EnsureUserIsSubscribed;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->web(append: [
            EnsureUserIsSubscribed::class,
        ]);
    });

​

Middleware-Parameter

Middleware kann zusätzliche Parameter aufnehmen. Nach $next in der handle-Methode können weitere Parameter folgen.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureUserHasRole
{
    public function handle(Request $request, Closure $next, string $role): Response
    {
        if (! $request->user()->hasRole($role)) {
            return redirect('/home');
        }

        return $next($request);
    }
}

In der Route trennen Sie Middleware-Namen und Parameter mit :.

use App\Http\Middleware\EnsureUserHasRole;

Route::put('/post/{id}', function (string $id) {
    // ...
})->middleware(EnsureUserHasRole::class.':editor');

Mehrere Parameter trennen Sie mit Komma.

Route::put('/post/{id}', function (string $id) {
    // ...
})->middleware(EnsureUserHasRole::class.':editor,publisher');

​

Beispiel: Auth-Check-Middleware

Ein einfaches Beispiel, das nicht angemeldete Nutzer umleitet.

php artisan make:middleware RedirectIfNotAuthenticated

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class RedirectIfNotAuthenticated
{
    public function handle(Request $request, Closure $next): Response
    {
        if (! $request->user()) {
            return redirect('/login');
        }

        return $next($request);
    }
}

Anwendung auf eine Route:

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware(RedirectIfNotAuthenticated::class);

Laravel bringt bereits die Middleware auth für Authentifizierung mit. Prüfen Sie zuerst, ob eine vorhandene Middleware Ihre Anforderungen erfüllt.

​

Nächste Schritte

HTTP-Requests

Lernen Sie, wie Sie in Controllern Anfragedaten empfangen.