Projects [SHOW]

Defining Middleware

Um eine neue Middleware zu erstellen, verwenden Sie den Artisan Befehl make:middleware:

Dieser Befehl platziert eine neue CheckAge-Klasse in Ihrem App/Http/Middleware-Verzeichnis. In dieser Middleware erlauben wir den Zugriff auf die Route nur, wenn das angegebene Age größer als 200 Jahre ist. Andernfalls werden wir die Benutzer zurück zur Home-Url umgeleitet:

<?php

namespace App\Http\Middleware;

use Closure;

class CheckAge
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        if ($request->age <= 200) {
            return redirect('home');
        }

        return $next($request);
    }
}

Wie Sie sehen können, wenn das angegebene Alter kleiner oder gleich 200 ist, gibt die Middleware einen HTTP-Redirect an den Client zurück, andernfalls wird die Anfrage weiter an die Anwendung weitergeleitet. Um die Anfrage tiefer in die Anwendung zu leiten (so dass die Middleware "übergeben" kann), rufen Sie den $next Callback mit der $request auf.

Es ist am besten, sich Middleware vorzustellen, da eine Reihe von "Layers" von HTTP-Anfragen durchlaufen werden müssen, bevor sie Ihre Anwendung erreichen. Jede Ebene kann die Anfrage prüfen und sogar vollständig ablehnen.

Before & After Middleware

Ob eine Middleware vor oder nach einer Anfrage läuft, hängt von der Middleware selbst ab. Beispielsweise würde die folgende Middleware eine Aufgabe ausführen, bevor die Anforderung von der Anwendung bearbeitet wird:

<?php

namespace App\Http\Middleware;

use Closure;

class BeforeMiddleware
{
    public function handle($request, Closure $next)
    {
        // Perform action

        return $next($request);
    }
}

Diese Middleware würde jedoch ihre Aufgabe erfüllen, nachdem die Anfrage von der Anwendung bearbeitet wurde:

<?php

namespace App\Http\Middleware;

use Closure;

class AfterMiddleware
{
    public function handle($request, Closure $next)
    {
        $response = $next($request);

        // Perform action

        return $response;
    }
}

Global Middleware

Wenn Sie möchten, dass eine Middleware bei jeder HTTP-Anfrage an Ihre Anwendung ausgeführt wird, listen Sie die Middleware-Klasse in der Eigenschaft $middleware Ihrer app/Http/Kernel.php-Klasse auf.

Assigning Middleware To Routes

Wenn Sie Middleware bestimmten Routen zuordnen möchten, sollten Sie der Middleware zunächst einen Schlüssel in Ihrer app/Http/Kernel.php-Datei zuweisen. Standardmäßig enthält die $routeMiddleware-Eigenschaft dieser Klasse Einträge für die mit Laravel mitgelieferte Middleware. Um Ihre eigenen hinzuzufügen, fügen Sie sie an diese Liste an und weisen Sie ihr einen Schlüssel Ihrer Wahl zu. Zum Beispiel:

// Within App\Http\Kernel Class...

protected $routeMiddleware = [
    'auth' => \Illuminate\Auth\Middleware\Authenticate::class,
    'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
    'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
    'can' => \Illuminate\Auth\Middleware\Authorize::class,
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
    'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
];

Nachdem die Middleware im HTTP-Kernel definiert wurde, können Sie mit der Middleware-Methode einer Route Middleware zuordnen:

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

Sie können der Route auch mehrere Middleware zuordnen:

Route::get('/', function () {
    //
})->middleware('first', 'second');

Bei der Zuweisung von Middleware können Sie auch den voll qualifizierten Klassennamen übergeben:

use App\Http\Middleware\CheckAge;

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

Middleware Groups

Manchmal kann es sinnvoll sein, mehrere Middleware unter einem einzigen Schlüssel zu gruppieren, um die Zuordnung zu Routen zu erleichtern. Sie können dies über die $middlewareGroups-Eigenschaft Ihres HTTP-Kernels tun.

Laravel wird standardmäßig mit Web- und Api-Middleware-Gruppen geliefert, die gemeinsame Middleware enthalten, die Sie vielleicht auf Ihre Web-Benutzeroberfläche und API-Routen anwenden möchten:

/**
 * The application's route middleware groups.
 *
 * @var array
 */
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
         \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    'api' => [
        'throttle:60,1',
        'auth:api',
    ],
];

Middleware-Gruppen können Routen und Controller-Aktionen zugeordnet werden, wobei die Syntax der einzelnen Middleware entspricht. Auch hier machen es Middleware-Gruppen einfacher, einer Route mehrere Middleware auf einmal zuzuordnen:

Route::get('/', function () {
    //
})->middleware('web');

Route::group(['middleware' => ['web']], function () {
    //
});

Middleware Parameters

Die Middleware kann auch zusätzliche Parameter empfangen. Wenn Ihre Anwendung beispielsweise überprüfen muss, ob der authentifizierte Benutzer eine bestimmte "Rolle" hat, bevor sie eine bestimmte Aktion ausführt, können Sie eine CheckRole-Middleware erstellen, die einen Rollennamen als zusätzliches Argument erhält.

Zusätzliche Middleware-Parameter werden nach dem Argument $next an die Middleware übergeben:

<?php

namespace App\Http\Middleware;

use Closure;

class CheckRole
{
    /**
     * Handle the incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  string  $role
     * @return mixed
     */
    public function handle($request, Closure $next, $role)
    {
        if (! $request->user()->hasRole($role)) {
            // Redirect...
        }

        return $next($request);
    }

}

Middleware-Parameter können bei der Definition der Route angegeben werden, indem der Name der Middleware und die Parameter durch ein  :  getrennt werden. Mehrere Parameter sollten durch Kommas getrennt werden:

Route::put('post/{id}', function ($id) {
    //
})->middleware('role:editor');

Terminable Middleware

Manchmal muss eine Middleware etwas arbeiten, nachdem die HTTP-Antwort vorbereitet wurde. Beispielsweise schreibt die in Laravel enthaltene "Session"-Middleware die Sitzungsdaten in den Speicher, nachdem die Antwort vollständig vorbereitet wurde. Wenn Sie eine terminate-Methode auf Ihrer Middleware definieren, wird sie automatisch aufgerufen, nachdem die Antwort zum Senden an den Browser bereit ist.

<?php

namespace Illuminate\Session\Middleware;

use Closure;

class StartSession
{
    public function handle($request, Closure $next)
    {
        return $next($request);
    }

    public function terminate($request, $response)
    {
        // Store the session data...
    }
}

Die terminate-Methode sollte sowohl den Request als auch den Response empfangen. Nachdem Sie eine terminierbare Middleware definiert haben, sollten Sie sie in der Datei app/Http/Kernel.php zur Liste der Route oder globalen Middleware hinzufügen.

Beim Aufruf der terminate-Methode auf Ihrer Middleware löst Laravel eine neue Instanz der Middleware aus dem Service-Container auf. Wenn Sie beim Aufruf der Methoden handle und terminate die gleiche Middleware-Instanz verwenden möchten, registrieren Sie die Middleware mit der Singleton-Methode des Containers am Container.