Utvecklare som syssnar med backend, stöter så småningom på routes. Routes kan betraktas som ryggraden i backend eftersom varje begäran som servern tar emot omdirigeras till en styrenhet via en routningslista som mappar begäranden till styrenheter eller åtgärder.

Laravel döljer många implementeringsdetaljer för oss och inkluderar en hel del hjälpmedel så att både nya och erfarna utvecklare kan utveckla sina webbapplikationer.

Låt oss ta en närmare titt på hur man hanterar routes i Laravel.

Backend Routing och Cross-Site Scripting i Laravel

På en server så finns det både offentliga och privata routes. Offentliga routes kan vara ett bekymmer på grund av möjligheten till cross-site scripting (XSS), en typ av injektionsattack som kan göra dig och dina användare sårbara för illvilliga aktörer.

Problemet är att en användare kan omdirigeras från en route som inte kräver en sessions-token till en route som kräver detta – och de har fortfarande tillgång utan token.

Det enklaste sättet att lösa problemet är att införa en ny HTTP-huvudrubrik och lägga till ”referrer” i routen för att minska detta scenario:

'main' => [
  'path' => '/main',
  'referrer' => 'required,refresh-empty',
  'target' => ControllerDashboardController::class . '::mainAction'
]

Laravel Basic Routing

I Laravel så gör routes det möjligt för användare att dirigera lämplig förfrågan till den önskade kontrollanten. Den mest grundläggande Laravel-routen accepterar en Uniform Asset Identifier (din route-väg) och en closure som kan vara både en funktion eller en klass.

I Laravel så skapas routes i filerna web.php och api.php. Laravel har som standard två routes: en för WEB och en för API.

Dessa routes finns i mappen routes/, men de laddas i Providers/RouteServiceProvider.php.

Standardtillstånd för Laravels routetjänst-leverantör.
Standardtillstånd för Laravels routetjänst-leverantör.

Istället för att göra detta så kan vi ladda routes direkt i RouteServiceProvider.php och hoppa över mappen routes/ helt och hållet.

Laddning av Laravel-routes direkt i leverantören.
Laddning av Laravel-routes direkt i leverantören.

Omdirigeringar

När vi definierar en route så vill vi vanligtvis omdirigera användaren som når den, och orsakerna till detta varierar mycket. Det kan bero på att det är en föråldrad route och att vi har ändrat backend eller servern, eller så kan det bero på att vi vill installera tvåfaktorsautentisering (2FA) och så vidare.

Laravel har ett enkelt sätt att göra detta på. Tack vare ramverkets enkelhet så kan vi använda omdirigerings-metoden på Route-fasaden, som accepterar ingångs-routen och routen som omdirigeringen ska ske till.

Eventuellt så kan vi ange statuskoden för omdirigeringen som tredje parameter. Metoden permanentRedirect gör samma sak som metoden redirect, förutom att den alltid returnerar en 301-statuskod:

// Simple redirect
Route::redirect("/class", "/myClass");

// Redirect with custom status
Route::redirect("/home", "/office", 305);

// Route redirect with 301 status code
Route::permanentRedirect("/home", "office");

I omdirigerings-routes är det förbjudet att använda nyckelorden ”destination” och ”status” som parametrar eftersom de är reserverade av Laravel.

// Illegal to use
Route::redirect("/home", "/office/{status}");

Vyer

Vyer är de .blade.php-filer som vi använder för att återge frontend för vår Laravel-applikation. Den använder blade templating engine, och det är standardmetoden för att bygga en fullstack-applikation med enbart Laravel.

Om vi vill att vår route ska returnera en vy så kan vi helt enkelt använda vy-metoden på Route-fasaden. Den accepterar en vägparameter, ett vynamn och en valfri array av värden som ska skickas till vyn.

// When the user accesses my-domain.com/homepage
// the homepage.blade.php file will be rendered
Route::view("/homepage", "homepage");

Låt oss anta att vår vy vill säga ”Hello, {name}” genom att skicka en valfri array med den parametern. Vi kan göra just detta med följande kod (om den saknade parametern krävs i vyn så kommer begärandet att misslyckas och ett fel visas):

Route::view('/homepage', 'homepage', ['name' => "Kinsta"]);

Route-lista

I takt med att din applikation växer i storlek så ökar också antalet förfrågningar som måste dirigeras. Och med en stor mängd information så kan det uppstå stor förvirring.

Det är här som artisan route:list command kan hjälpa oss. Den ger en översikt över alla routes som är definierade i applikationen, deras middlewares och controllers.

php artisan route:list

Den visar en lista över alla routes utan middlewares. För detta måste vi använda flaggan -v:

php artisan route:list -v

I en situation där du kanske använder en domänstyrd design där dina routes har specifika namn i sina sökvägar kan du använda filtreringsmöjligheterna i det här kommandot på följande sätt:

php artisan route:list –path=api/account

Detta visar endast de routes som börjar med api/account.

Å andra sidan så kan vi instruera Laravel att utesluta eller inkludera tredjepartsdefinierade routes genom att använda alternativen –except-vendor eller –only-vendor.

Route-parametrar

Ibland så kan du behöva fånga upp segment av URI:n med din route, exempelvis ett användar-ID eller en token. Vi kan göra detta genom att definiera en route-parameter, som alltid är inkapslad inom parenteser ({}) och som endast bör bestå av alfabetiska tecken.

Om våra routes har beroenden i sina callbacks så kommer Laravel-tjänstecontainern automatiskt att injicera dem:

use IlluminateHttpRequest;
use Controllers/DashboardController;
Route::post('/dashboard/{id}, function (Request $request, string $id) {
  return 'User:' . $id;
}
Route::get('/dashboard/{id}, DashboardController.php);

Parametrar som krävs

Laravels obligatoriska parametrar är parametrar i routes som vi inte får hoppa över när vi gör ett anrop. I annat fall så kommer ett fel att uppstå:

Route::post("/gdpr/{userId}", GetGdprDataController.php");

Nu har vi direkt tillgång till parametern $userId i GetGdprDataController.php.

public function __invoke(int $userId) {
  // Use the userId that we received…
}

En route kan ta emot ett obegränsat antal parametrar. De injiceras i vägkallelserna/controllers baserat på den ordning i vilken de listas:

 // api.php
Route::post('/gdpr/{userId}/{userName}/{userAge}', GetGdprDataController.php);
// GetGdprDataController.php
public function __invoke(int $userId, string $userName, int $userAge) {
  // Use the parameters…
}

Valfria parametrar

I en situation där vi vill göra något på en route när endast en parameter är närvarande och inget annat, utan att påverka hela applikationen , kan vi lägga till en valfri parameter. Dessa valfria parametrar betecknas med ? som bifogas dem:

 Route::get('/user/{age?}', function (int $age = null) {
  if (!$age) Log::info("User doesn't have age set");
  else Log::info("User's age is " . $age);
}
Route::get('/user/{name?}', function (int $name = "John Doe") {
  Log::info("User's name is " . $name);
}

Route Wildcard

Laravel erbjuder ett sätt för oss att filtrera hur våra valfria eller obligatoriska parametrar ska se ut.

Säg att vi vill ha en sträng av ett användar-ID. Vi kan validera det så här på route-nivå med hjälp av metoden where.

Metoden where accepterar namnet på parametern och den regexregel som ska tillämpas på valideringen. Som standard så tar metoden den första parametern, men om vi har många så kan vi skicka en array med parameterns namn som nyckel och regeln som värde, så analyserar Laravel dem alla åt oss:

Route::get('/user/{age}', function (int $age) {
  //
}->where('age', '[0-9]+');
Route::get('/user/{age}', function (int $age) {
  //
}->where('[0-9]+');
Route::get('/user/{age}/{name}', function (int $age, string $name) {
  //
}->where(['age' => '[0-9]+', 'name' => '[a-z][A-z]+');

Vi kan ta detta ett steg längre och tillämpa validering på alla vägar i vår applikation genom att använda pattern-metoden på Route-fasaden:

 Route::pattern('id', '[0-9]+');

Detta validerar varje id-parameter med det här regexuttrycket. Och när vi väl har definierat detta så kommer det automatiskt att tillämpas på alla routes som använder det parameternamnet.

Som vi kan se så använder Laravel tecknet / som en separator i sökvägen. Om vi vill använda det i sökvägen så måste vi uttryckligen tillåta att det är en del av vår platscontainer med hjälp av ett where-regex.

 Route::get('/find/{query}', function ($query) {
  //
})->where('query', , '.*');

Den enda nackdelen är att det endast kommer att stödjas i det sista route-segmentet.

Namngivna routes

Som namnet antyder så kan vi namnge routes, vilket gör det bekvämt att generera webbadresser eller omdirigeringar för specifika routes.

Hur man skapar namngivna routes

Ett enkelt sätt att skapa en namngiven route tillhandahålls av metoden name som är kedjad på Route-fasaden. Varje routes namn bör vara unikt:

 Route::get('/', function () {
})->name("homepage");

Route-grupper

Route-grupper gör det möjligt att dela route-attribut, t.ex. middlewares, på ett stort antal routes utan att behöva omdefiniera dem på varje enskild route.

Middleware

Genom att tilldela en middleware till alla routes som vi har så kan vi kombinera dem i en grupp, först med hjälp av metoden group. En sak att tänka på är att middlewares exekveras i den ordning som de tillämpas på gruppen:

 Route:middleware(['AuthMiddleware', 'SessionMiddleware'])->group(function () {
  Route::get('/', function() {} );
  Route::post('/upload-picture', function () {} );
});

Controllers

När en grupp använder samma styrenhet så kan vi använda metoden controller för att definiera den gemensamma styrenheten för alla routes  i gruppen. Nu måste vi ange den metod som routen ska anropa.

 Route::controller(UserController::class)->group(function () {
  Route::get('/orders/{userId}', 'getOrders');
  Route::post('/order/{id}', 'postOrder');
});

Routning av underdomäner

Ett underdomännamn är en bit tilläggsinformation som läggs till i början av en webbplats domännamn. Detta gör det möjligt för webbplatser att separera och organisera sitt innehåll för specifika funktioner. Det kan inkludera nätbutiker, bloggar, presentationer och så vidare från resten av webbplatsen.

Våra routes kan användas för att hantera routning av underdomäner. Vi kan fånga upp domänen och en del av underdomänen för användning i vår controller och route. Med hjälp av metoden domain på fasaden Route så kan vi gruppera våra routes under en enda domän:

 Route::domain('{store}.enterprise.com')->group(function() {
  Route::get('order/{id}', function (Account $account, string $id) {
    // Your Code
  }
});

Prefix och namnprefix

När vi har en grupp av routes så kan vi, i stället för att ändra dem en och en, använda oss av de extra verktyg som Laravel tillhandahåller. Detta inkluderar exempelvis prefix och name på fasaden Route.

Metoden prefix kan användas för att prefixera varje route i gruppen med en given URI, och metoden name kan användas för att prefixera varje route-namn med en given sträng.

Detta gör att vi kan skapa nya saker som administrations-routes utan att behöva ändra varje enskilt namn eller prefix för att identifiera dem:

 Route::name('admin.")->group(function() {
  Route::prefix("admin")->group(function() {
    Route::get('/get')->name('get');
    Route::put('/put')->name(put');
    Route::post('/post')->name('post');
  });
});

Nu kommer URI:erna för dessa routes att vara admin/get, admin/put, admin/post, och namnen admin.get, admin.put och admin.post.

Cachelagring av routes

När applikationen distribueras till produktionsservrar så kommer en bra Laravel-utvecklare att dra nytta av Laravels route cache.

Vad är Route Cachelagring?

Route cachelagring minskar den tid som det tar att registrera alla applikations-routes.

Genom att köra php artisan route:cache så genereras en instans av Illuminate/Routing/RouteCollection och efter att ha kodats så skrivs det serialiserade resultatet till bootstrap/cache.routes.php.

Nu kommer alla andra förfrågningar att ladda denna cache-fil om den finns. Vår applikation behöver därför inte längre analysera och konvertera poster från route-filen till Illuminate/Routing/Route-objekt i Illuminate/Routing/RouteCollection.

Varför det är viktigt att använda Route Cachelagring

Om du inte använder route cachelagrings-funktionen som Laravel tillhandahåller så riskerar din applikation att köras långsammare än vad den skulle kunna göra, vilket i sin tur kan minska försäljningen, användarretentionen och förtroendet för ditt varumärke.

Beroende på projektets storlek och hur många routes som det finns kan ett enkelt route cachelagrings-kommando snabba upp din applikation med allt ifrån 130 % till 500 % – en enorm vinst för nästan ingen ansträngning alls.

Sammanfattning

Routing är ryggraden i backendutvecklingen. Laravel-ramverket utmärker sig på detta genom att tillhandahålla ett utförligt sätt att definiera och hantera routes.

Utveckling kan verkligen vara tillgänglig för alla och bidra till att snabba upp en applikation bara genom att den är byggd i Laravel.

Vilka andra tricks och tips har du stött på när det gäller Laravel-routes? Låt oss veta i kommentarsfältet!

Coman Cosmin

Cosmin Coman är en teknikskribent och utvecklare med över 3 års erfarenhet. Förutom att skriva för Kinsta har han hjälpt till med forskning vid kärnfysikanläggningar och universitet. Han är teknikkunnig och integrerad i samhället och kommer alltid med innovativa lösningar.