> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](/de/csrf).

<Info>
  Ihre eigenen Middleware legen Sie üblicherweise unter `app/Http/Middleware` ab.
</Info>

```mermaid theme={null}
flowchart TD
    A["HTTP-Anfrage"] --> B["Globale Middleware<br>(auf alle Anfragen angewendet)"]
    B --> C["Route-Middleware<br>(auf bestimmte Routen)"]
    C --> D["Controller / Closure"]
    D --> E["Antwort erzeugen"]
    E --> F["Route-Middleware<br>(Nachverarbeitung)"]
    F --> G["Globale Middleware<br>(Nachverarbeitung)"]
    G --> H["HTTP-Antwort"]
```

## 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`.

```shell theme={null}
php artisan make:middleware EnsureTokenIsValid
```

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

```php theme={null}
<?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.

```php theme={null}
// Vor dem Request
public function handle(Request $request, Closure $next): Response
{
    // Vorverarbeitung hier

    return $next($request);
}
```

```php theme={null}
// 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.

```php theme={null}
// 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.

```php theme={null}
use App\Http\Middleware\EnsureTokenIsValid;

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

Mehrere Middleware übergeben Sie als Array.

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

Zum Ausschluss einer Middleware auf einer bestimmten Route dient `withoutMiddleware`.

```php theme={null}
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`.

```php theme={null}
// 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:

```php theme={null}
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`.

```php theme={null}
// 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.

```php theme={null}
Route::get('/', function () {
    // ...
})->middleware('group-name');

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

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

```php theme={null}
// 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 theme={null}
<?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 `:`.

```php theme={null}
use App\Http\Middleware\EnsureUserHasRole;

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

Mehrere Parameter trennen Sie mit Komma.

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

## Beispiel: Auth-Check-Middleware

Ein einfaches Beispiel, das nicht angemeldete Nutzer umleitet.

```shell theme={null}
php artisan make:middleware RedirectIfNotAuthenticated
```

```php theme={null}
<?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:

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

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

## Nächste Schritte

<Card title="HTTP-Requests" icon="globe" href="/de/requests">
  Lernen Sie, wie Sie in Controllern Anfragedaten empfangen.
</Card>


## Related topics

- [Laravel AI SDK](/de/ai-sdk.md)
- [Laravel Folio](/de/folio.md)
- [OAuth-2.0-Authentifizierung - Google Sheets API for Laravel](/de/packages/laravel-google-sheets/oauth.md)
- [Laravel Pennant](/de/pennant.md)
- [Laravel Sentinel – Analyse der Route-Schutz-Middleware](/de/blog/sentinel-introduction.md)