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

> Leer hoe je met middleware in Laravel HTTP-requests filtert en voorbewerkt.

## Wat is middleware

Middleware is een mechanisme om binnenkomende HTTP-requests te inspecteren en te filteren.
Je kunt logica invoegen vóór en na het moment waarop het request aan de controller wordt doorgegeven.

Laravel bevat bijvoorbeeld authenticatiemiddleware.
Is een gebruiker niet geauthenticeerd, dan wordt hij geredirect naar het inlogscherm; is hij dat wel, dan laat de middleware het request gewoon door naar de rest van de applicatie.

Naast authenticatie kun je middleware maken voor allerlei doeleinden, zoals logging, CSRF-beveiliging en rate limiting. Zie [CSRF-beveiliging](/nl/csrf) voor details over de CSRF-bescherming in Laravel 13.

<Info>
  Middleware die je zelf definieert plaats je gewoonlijk in de directory `app/Http/Middleware`.
</Info>

```mermaid theme={null}
flowchart TD
    A["HTTP-request"] --> B["Globale middleware<br>(toegepast op alle requests)"]
    B --> C["Routemiddleware<br>(toegepast op specifieke routes)"]
    C --> D["Controller / closure"]
    D --> E["Response genereren"]
    E --> F["Routemiddleware<br>(nabewerking)"]
    F --> G["Globale middleware<br>(nabewerking)"]
    G --> H["HTTP-response"]
```

## Ingebouwde middleware

Laravel levert standaard twee middlewaregroepen: `web` en `api`.
Op `routes/web.php` wordt automatisch de `web`-groep toegepast en op `routes/api.php` de `api`-groep.

| `web`-middlewaregroep                      |
| ------------------------------------------ |
| `EncryptCookies`                           |
| `AddQueuedCookiesToResponse`               |
| `StartSession`                             |
| `ShareErrorsFromSession`                   |
| `PreventRequestForgery` (CSRF-beveiliging) |
| `SubstituteBindings`                       |

Voor veelgebruikte middleware zijn bovendien aliassen ingesteld, zodat je ze met een korte naam kunt refereren.

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

## Middleware maken

Met het Artisan-commando `make:middleware` maak je nieuwe middleware aan.

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

Dit genereert `app/Http/Middleware/EnsureTokenIsValid.php`.
In de `handle`-methode schrijf je de logica die het request verwerkt.

```php theme={null}
<?php

namespace App\Http\Middleware;

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

class EnsureTokenIsValid
{
    /**
     * Verwerk het binnenkomende request
     *
     * @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);
    }
}
```

Roep je `$next($request)` aan, dan wordt het request doorgegeven aan de volgende stap in de applicatie.
Wordt niet aan de voorwaarde voldaan, dan stop je het request door een redirect of response terug te geven.

### Verwerking vóór en na het request

Middleware kan logica uitvoeren **vóór** of **na** het request.

```php theme={null}
// Vóór het request verwerken
public function handle(Request $request, Closure $next): Response
{
    // Schrijf hier de voorbewerking

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

```php theme={null}
// Na de response verwerken
public function handle(Request $request, Closure $next): Response
{
    $response = $next($request);

    // Schrijf hier de nabewerking

    return $response;
}
```

## Middleware registreren

### Globale middleware

Wil je middleware uitvoeren voor alle requests, voeg die dan in `bootstrap/app.php` via `withMiddleware` toe aan de globale 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` voegt toe aan het einde van de stack. Gebruik `prepend` om aan het begin toe te voegen.

### Middleware toepassen op routes

Om middleware alleen op specifieke routes toe te passen, roep je in de routedefinitie de methode `middleware` aan.

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

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

Meerdere middleware geef je door als array.

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

Wil je middleware voor een specifieke route juist uitsluiten, gebruik dan `withoutMiddleware`.

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

Route::middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/', function () {
        // Op deze route wordt de middleware toegepast
    });

    Route::get('/profile', function () {
        // Deze route sluit de middleware uit
    })->withoutMiddleware([EnsureTokenIsValid::class]);
});
```

### Middleware-aliassen

Je kunt voor lange klassenamen een korte alias definiëren. Dat doe je 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,
        ]);
    });
```

Met de alias pas je de middleware toe op routes.

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

## Middlewaregroepen

Door meerdere middleware onder één sleutel te bundelen, wordt het toepassen op routes eenvoudiger.
In `bootstrap/app.php` gebruik je `appendToGroup` of `prependToGroup`.

```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,
        ]);
    });
```

Groepen pas je op routes toe op dezelfde manier als gewone middleware.

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

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

Wil je middleware toevoegen aan de bestaande `web`- of `api`-groep, dan zijn daar speciale methoden voor.

```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,
        ]);
    });
```

## Middlewareparameters

Middleware kan extra parameters ontvangen.
Je voegt de parameters toe na het argument `$next` van de `handle`-methode.

```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 de routedefinitie scheid je de middlewarenaam en de parameters met een `:`.

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

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

Meerdere parameters scheid je met komma's.

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

## Praktijkvoorbeeld: middleware voor een authenticatiecheck

Een eenvoudig voorbeeld dat niet-ingelogde gebruikers redirect.

```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);
    }
}
```

Pas de middleware toe op een route.

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

<Tip>
  Laravel heeft een ingebouwde `auth`-middleware voor authenticatie. Controleer voordat je zelf iets implementeert of de bestaande middleware al aan je eisen voldoet.
</Tip>

## Volgende stappen

<Card title="HTTP-requests" icon="globe" href="/nl/requests">
  Leer hoe je in controllers requestdata ontvangt.
</Card>


## Related topics

- [Laravel Folio](/nl/folio.md)
- [Laravel AI SDK](/nl/ai-sdk.md)
- [OAuth 2.0-authenticatie - Google Sheets API for Laravel](/nl/packages/laravel-google-sheets/oauth.md)
- [Laravel Pennant](/nl/pennant.md)
- [Laravel Sentinel — verkenning van de routebeschermings-middleware](/nl/blog/sentinel-introduction.md)