Basics - 01. Routing

Named Routes

Named Routes ermöglichen die komfortable Generierung von URLs oder Umleitungen für bestimmte Routen. Sie können einen Namen für eine Route angeben, indem Sie die Name-Methode mit der Routendefinition verknüpfen:

Route::get('user/profile', function () {
    //
})->name('profile');

Sie können auch Routennamen für Controller Aktionen angeben:

Route::get('user/profile', 'UserProfileController@show')->name('profile');

Generating URLs To Named Routes

Nachdem Sie einer bestimmten Route einen Namen zugewiesen haben, können Sie den Namen der Route bei der Generierung von URLs oder Umleitungen über die globale Route-Funktion verwenden:

// Generating URLs...
$url = route('profile');

// Generating Redirects...
return redirect()->route('profile');

Wenn die named Route Parameter definiert, können Sie die Parameter als zweites Argument an die Route-Funktion übergeben. Die angegebenen Parameter werden automatisch an der richtigen Stelle in die URL eingefügt:

Route::get('user/{id}/profile', function ($id) {
    //
})->name('profile');

$url = route('profile', ['id' => 1]);

Inspecting The Current Route

Wenn Sie feststellen möchten, ob die aktuelle Anforderung an eine bestimmte benannte Route weitergeleitet wurde, können Sie die named Methode auf einer Route-Instanz verwenden. So können Sie beispielsweise den aktuellen Routennamen von einer Route-Middleware aus überprüfen:

/**
 * Handle an incoming request.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Closure  $next
 * @return mixed
 */
public function handle($request, Closure $next)
{
    if ($request->route()->named('profile')) {
        //
    }

    return $next($request);
}

Route Groups

Route-Groups ermöglichen es Ihnen, Routenattribute, wie z. B. Middleware oder Namensräume, über eine große Anzahl von Routen gemeinsam zu nutzen, ohne diese Attribute auf jeder einzelnen Route definieren zu müssen. Gemeinsame Attribute werden in einem Array-Format als erster Parameter der Route::group-Methode angegeben.

Verschachtelte Gruppen versuchen, Attribute intelligent mit ihrer übergeordneten Gruppe "zusammenzuführen". Middleware und where Bedingungen zusammengeführt werden, während Namen, Namensräume und Präfixe angehängt werden. Namensraumbegrenzungen und Schrägstriche in URI-Präfixen werden gegebenenfalls automatisch hinzugefügt.

Middleware

Um allen Routen innerhalb einer Gruppe Middleware zuzuordnen, können Sie die Middleware-Methode verwenden, bevor Sie die Gruppe definieren. Middleware wird in der Reihenfolge ausgeführt, in der sie im Array aufgelistet ist:

Route::middleware(['first', 'second'])->group(function () {
    Route::get('/', function () {
        // Uses first & second Middleware
    });

    Route::get('user/profile', function () {
        // Uses first & second Middleware
    });
});

Namespaces

Ein weiterer häufiger Anwendungsfall für Routengruppen ist die Zuweisung des gleichen PHP-Namensraums an eine Gruppe von Controllern über die namespace-Methode:

Route::namespace('Admin')->group(function () {
    // Controllers Within The "App\Http\Controllers\Admin" Namespace
});

Sub-Domain Routing

Routengruppen können auch für das Routing von Subdomänen verwendet werden. Subdomänen können Routenparameter genauso wie Routen-URIs zugewiesen werden, so dass Sie einen Teil der Subdomäne zur Verwendung in Ihrer Route oder Steuerung erfassen können. Die Subdomäne kann durch Aufruf der Domain-Methode vor der Definition der Gruppe spezifiziert werden:

Route::domain('{account}.myapp.com')->group(function () {
    Route::get('user/{id}', function ($account, $id) {
        //
    });
});

Route Prefixes

Die Prefix-Methode kann verwendet werden, um jede Route in der Gruppe mit einer bestimmten URI zu präfixieren. Beispielsweise können Sie allen Routing-URIs innerhalb der Gruppe mit admin voranstellen:

Route::prefix('admin')->group(function () {
    Route::get('users', function () {
        // Matches The "/admin/users" URL
    });
});

Route Name Prefixes

Die Name-Methode kann verwendet werden, um jedem Routennamen in der Gruppe eine Zeichenkette voranzustellen. Beispielsweise können Sie allen Namen der gruppierten Route ein Präfix mit admin voranstellen. Die angegebene Zeichenkette wird dem Routennamen genau so vorangestellt, wie er angegeben ist, so dass wir sicher sein können, dass wir das Zeichen trailing . im Präfix angeben:

Route::name('admin.')->group(function () {
    Route::get('users', function () {
        // Route assigned name "admin.users"...
    })->name('users');
});

Route Model Binding

Wenn Sie eine Modell-ID in eine Route oder eine Steuerungsaktion einfügen, werden Sie oft nach dem Modell fragen, das dieser ID entspricht. Die Laravel-Routenmodellbindung bietet eine komfortable Möglichkeit, die Modellinstanzen automatisch direkt in Ihre Routen einzubinden. Anstatt beispielsweise die ID eines Benutzers zu injizieren, können Sie die gesamte Instanz des User-Modells injizieren, die mit der angegebenen ID übereinstimmt.

Implicit Binding

Laravel löst automatisch Eloquent Modelle auf, die in Routen oder Controller-Aktionen definiert sind, deren type-hinted Variablennamen mit einem Routensegmentnamen übereinstimmen. Zum Beispiel:

Route::get('api/users/{user}', function (App\User $user) {
    return $user->email;
});

Da die Variable $user als App\User Eloquent model typgehint ist und der Variablenname mit dem {user} übereinstimmt. URI-Segment wird Laravel automatisch die Modellinstanz injizieren, die eine ID hat, die dem entsprechenden Wert aus dem AnforderungsURI entspricht. Wenn keine passende Modellinstanz in der Datenbank gefunden wird, wird automatisch eine 404 HTTP-Antwort generiert.

Customizing The Key Name

Wenn Sie möchten, dass die Modellbindung beim Abrufen einer bestimmten Modellklasse eine andere Datenbankspalte als id verwendet, können Sie die Methode getRouteKeyName auf dem Eloquent Modell überschreiben:

/**
 * Get the route key for the model.
 *
 * @return string
 */
public function getRouteKeyName()
{
    return 'slug';
}

Explicit Binding

Um eine explizite Bindung zu registrieren, verwenden Sie die Model-Methode des Routers, um die Klasse für einen bestimmten Parameter anzugeben. Ihre expliziten Model-Bindungen sollten Sie in der Boot-Methode der Klasse RouteServiceProvider definieren:

public function boot()
{
    parent::boot();

    Route::model('user', App\User::class);
}

Next, define a route that contains a {user} parameter:

Route::get('profile/{user}', function (App\User $user) {
    //
});

Da wir alle {user} Parameter an das App\User-Modell gebunden haben, wird eine User-Instanz in die Route eingefügt. So wird beispielsweise eine Anforderung an Profil/1 die User-Instanz aus der Datenbank mit der ID 1 injizieren.

Wenn keine passende Modellinstanz in der Datenbank gefunden wird, wird automatisch eine 404 HTTP-Antwort generiert.

Customizing The Resolution Logic

Wenn Sie Ihre eigene Auflösungslogik verwenden möchten, können Sie die Route::bind-Methode verwenden. Der Closure, den Sie an die Bind-Methode übergeben, erhält den Wert des URI-Segments und sollte die Instanz der Klasse zurückgeben, die in die Route injiziert werden soll:

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    Route::bind('user', function ($value) {
        return App\User::where('name', $value)->first() ?? abort(404);
    });
}

Alternativ können Sie die resolveRouteBinding-Methode in Ihrem Eloquent Modell überschreiben. Diese Methode empfängt den Wert des URI-Segments und sollte die Instanz der Klasse zurückgeben, die in die Route injiziert werden soll:

/**
 * Retrieve the model for a bound value.
 *
 * @param  mixed  $value
 * @return \Illuminate\Database\Eloquent\Model|null
 */
public function resolveRouteBinding($value)
{
    return $this->where('name', $value)->first() ?? abort(404);
}

Fallback Routes

Mit der Methode Route::Fallback können Sie eine Route definieren, die ausgeführt wird, wenn keine andere Route mit der eingehenden Anforderung übereinstimmt. Normalerweise wird bei unbehandelten Anfragen automatisch eine "404"-Seite über den Ausnahmebehandler Ihrer Anwendung angezeigt. Da Sie jedoch die Fallback-Route in Ihrer Datei routes/web.php definieren können, gilt für die Route die gesamte Middleware in der Gruppe web middleware. Es steht Ihnen frei, dieser Route bei Bedarf zusätzliche Middleware hinzuzufügen:

Route::fallback(function () {
    //
});

Rate Limiting

Laravel enthält eine Middleware, um den Zugriff auf Routen innerhalb Ihrer Anwendung einzuschränken. Ordnen Sie die throttle-Middleware einer Route oder einer Gruppe von Routen zu. Die throttle-Middleware akzeptiert zwei Parameter, die die maximale Anzahl von Anforderungen bestimmen, die in einer bestimmten Anzahl von Minuten gestellt werden können. Geben Sie beispielsweise an, dass ein authentifizierter Benutzer 60 Mal pro Minute auf die folgende Gruppe von Routen zugreifen kann:

Route::middleware('auth:api', 'throttle:60,1')->group(function () {
    Route::get('/user', function () {
        //
    });
});

Dynamic Rate Limiting

Sie können ein Maximum für dynamische Anfragen angeben, das auf einem Attribut des authentifizierten User basiert. Wenn Ihr User beispielsweise ein rate_limit-Attribut enthält, können Sie den Namen des Attributs an die throttle-Middleware übergeben, so dass es zur Berechnung der maximalen Anzahl der Anforderungen verwendet wird:

Route::middleware('auth:api', 'throttle:rate_limit,1')->group(function () {
    Route::get('/user', function () {
        //
    });
});

Form Method Spoofing

HTML-Formulare unterstützen keine PUT-, PATCH- oder DELETE-Aktionen. Wenn Sie also PUT-, PATCH- oder DELETE-Routen definieren, die von einem HTML-Formular aufgerufen werden, müssen Sie dem Formular ein verstecktes _method Field hinzufügen. Der mit dem _method Field gesendete Wert wird als HTTP-Anforderungsmethode verwendet:

<form action="/foo/bar" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <input type="hidden" name="_token" value="{{ csrf_token() }}">
</form>

Sie können die @method Blade Direktive verwenden, um die _method Eingabe zu generieren:

<form action="/foo/bar" method="POST">
    @method('PUT')
    @csrf
</form>

Accessing The Current Route

Sie können die Methoden current, currentRouteName und currentRouteAction auf der Route-Facade verwenden, um auf Informationen über die Route zuzugreifen, die die eingehende Anforderung bearbeitet:

$route = Route::current();

$name = Route::currentRouteName();

$action = Route::currentRouteAction();

Lesen Sie die API-Dokumentation sowohl für die zugrunde liegende Klasse der Route-Facade als auch für die Route-Instance, um alle verfügbaren Methoden zu überprüfen.