Роуты (route) и роутинг в Laravel 5, полное руководство, примеры и подсказки

  • DeveloperNotes
  • »
  • Laravel 5
  • »
  • Роуты (route) и роутинг в Laravel 5, полное руководство, примеры и подсказки

Давайте начнем с самого начала и ответим на вопрос - зачем в Laravel вообще нужны роуты, роутинги и что это такое? Если кратко: роут представляет из себя шаблон URI, задав который, вы объясните Laravel какой код должен обработать обращение к этому URI. Звучит не очень понятно, давайте объясню подробнее.

Что такое роуты (route) в Laravel?

Если говорить грубо, существует два типа URL'ов (надеюсь, объяснять, что такое URL - не нужно). Абсолютный и относительный. Абсолютный URL включает в себя имя домена, например: https://developernotes.ru/laravel-5. Относительный же имя домена в себя не включает, например: /laravel-5

Когда вы пишите относительный URL, вы как бы подразумеваете, что речь идет о уже известном сайте. Например, если я попрошу вас перейти по ссылке /xampp на этом сайте, вы наверняка поймете, что речь идет о developernotes.ru/xampp.

Относительный URL обычно называется URI. Я объясняю "на пальцах", и за дополнительной информацией очень рекомендую сходить в википедию. Развивает, знаете ли.

Но кроме того, что у нас есть простые ссылки (как /xampp), могут быть и более сложные. Например /category-1/category-2/category-3/product-link. Например, похожий URL можно встретить в каком-нибудь интернет-магазине.

Как вы помните, Laravel работает по модели MVC. Модель-представление-контроллер. И route позволяет нам "связать" запрашиваемый адрес и определенный метод контроллера таким образом, чтобы при запрашивании этого адреса вызывался именно этот метод.

То есть отправной точкой у нас является роут. И если не задан ни один, то наше приложение не сможет "начаться".

На самом деле route читается как "рут". Но, видимо, чтобы не путать с именем супер-пользователя в Linux (root) или корнем сайта (root directory), на русском языке его называют обычно "роут". А может быть просто по незнанию. Безграмотные ублюдки. Зато понятно!

Давайте напишем свой первый роут, который обрабатывал бы обращение к главной странице сайта.

Создайте любой контроллер, который вы хотите. Я обычно называю его IndexController. И создайте в нем метод index() следующим образом:

namespace App\Http\Controllers;

class IndexController extends Controller
{
	public function index()
	{
			die ("Роут работает!");
	}
}

После чего откройте файл routes/web.php (предполагается, что в этом файле хранятся все роуты, относящиеся к браузеру; могут быть и другие). Удалите всё, что в нем есть (для чистоты эксперимента) и напишите строчку:

Route::get('/', 'IndexController@index')->name('index');

Откройте сайт и - вуаля! Мы видим слова "Роут работает", нам чем наш Laravel закономерно завершил работу.

Итак, что мы сделали? За всё здесь отвечает класс Route. Мы обратились к статическому методу get этого класса. В данном случае "get" - это в смысле "GET-запрос", а не "получить данные". То есть в данном случае мы обрабатываем именно get-запрос. Например, если мы хотим обработать POST-запрос, мы должны написать Route::post(...).

На самом деле, мы можем обработать довольно много разных типов HTTP-запросов, которые обычно используются в RESTfull API, такие как: put, delete, patch и другие, но это тема отдельной статьи.

Route имеет метод any (Route::any(...)). В этом случае он обработает запрос любого типа с казанным URI. Но я настоятельно не рекомендую пользоваться такой возможностью. Если вы так делаете, скорее всего вы не знаете - зачем. И это может повлечь ошибки, которые сразу можно и не предусмотреть.

Первым обязательным параметром является непосредственно URI. Обратите внимание, что для корневой страницы мы использовали значение /. То есть слеш без каких-либо параметров. Такой URI может быть только у корневой (индексной, главной) страницы сайта, ни у какой другой.

Вторым параметром мы передали название контроллера и метода в нем, куда Laravel должен передать управление. Название контроллера и метод в нем записывается через символ собаки (@). В принципе, ловко придумано. Сначала контроллер, потом собака, потом название метода. В нашем случае строка "IndexController@index" означает, что нужно обратиться к контроллеру IndexController и методу index внутри него.

Что такое name() я покажу чуть позже, не переживайте. Если в двух словах - эта функция используется для "именования" роута и для удобства программиста. В дальшейшем можно будет вызвать роут по этому имени внутри какого-нибудь blade-шаблона, а в качестве вернувшегося значения получить URI, который мы вписали в этот роут. Это нужно, например, на случай, если вы поменяли URI в web.php, но забыли поменять его где-то в шаблонах.

Как передать параметры в Route или "URL с параметрами"?

Давайте представим, что мы делаем блог, как у меня, только с более короткими URL'ами и они начинаются от корня сайта (то есть идут сразу после домена, через слеш). Тогда у этой статьи мог бы быть следующий URL: /route-v-laravel

Как вы понимаете, у меня может быть не одна статья в блоге. Например, какая-нибудь другая статья могла называться "Как ничего не понять в Ларавел за пять минут" и ее адрес был бы, например, таким: /kak-ne-ponyat-laravel

Для облегчения понимания сейчас мы не будем говорить о рубриках.

Обращаю ваше внимание, что когда я пишу пост, у поста есть так называемый "слаг" (по-английски: slug). Часто его называют "альясом" (alias). Если отбросить слеш в начале, вот эта часть - kak-ne-ponyat-laravel - и есть альяс. Или слаг. Он хранится в базе данных, как одно из полей у поста, вместе с заголовком, SEO-тегами и прочим. Обычно он содержит только цифры, буквы и дефисы (потому, что используется в адресной строке браузера). И используется для идентификации поста. Я объясню как это работает в комплексе чуть ниже.

Вернемся к нашему воображаемому блогу. Теперь нам надо прописать роут, который бы мог обработать запрос поста и передать управление куда нужно. В Laravel это не сложно, достаточно написать следующее в web.php:

Route::get('/{alias}', IndexController@post);

Обратите внимание, что alias здесь заключено в фигурные скобки. Если бы мы написали просто Route::get('/alias', ...); то этот роут обрабатывал бы исключительно страницу domain.com/alias, что совершенно не то поведение, которое мы хотим.

Теперь наш роут будет принимать все адреса подряд, которые пришли из GET-запроса. Он будет обрабатывать и /test и /123456 и наш пример /kak-ne-ponyat-laravel. Перенаправлять управление он будет в метод с название post (здесь имеется ввиду пост в блоге, а не POST-запрос!) контроллера IndexController (по-хорошему, нужно создать новый контроллер, который отвечал бы только за обработку постов и всё с ними связанное, но мне лень).

Кроме того, он передаст в метод контроллера переменную $alias (с именно тем названием, которое мы указали в Route::get). И мы сможем ее обработать! То есть в методе контроллера мы можем узнать, какой именно пост запросил пользователь, поискать его в базе данных. И соответствующим образом себя повести: или выдать 404-ую ошибку, если пост не найден. Или вывести содержимое поста, что и требовалось.

Давайте напишем этот метод (я предположу, что модели, таблицы и прочее уже готовы, т.к. это статья только про роуты):

public function post($alias)
{
    $post = Post::where('alias', '=', $alias)->first();

    if (is_null($post)) {
        abort(404);
    }

    return view('posts.post', ['post' => $post]);
}

Обращаю ваше внимание: мы получаем $alias в качестве параметра метода и нам не нужно делать что-либо еще. Спасибо Laravel за заботу!

Теперь давайте проанализируем всю связку в целом:

  • Мы прописали роут который принимает любой адрес по шаблону "слеш плюс любое количество любых символов". То есть все адреса, начинающиеся со слеша будут попадать под этот шаблон.
  • Любой адрес, набранный таким образом (например, /laravel) будет передан в контроллер IndexController методу post().
  • Туда же будет передана переменная $alias, в качестве параметра для этого метода (она не появится внутри тела метода волшебным образом, не забудьте ее прописывать!)
  • Теперь мы можем найти в базе данных пост блога с таким альясом, чтобы вывести его, что и делаем первым делом через модель Post.
  • Если пост по какой-то причине не найден (например, просто не написан), мы выводим страницу 404 с помощью функции-хелпера abort.
  • Если пост найден, мы выводим пост (рендерим представление posts/post.blade.php и передаем туда модель найденного поста из базы данных)

Как задать вложенные URL'ы?

Чтобы стало совсем понятно, я покажу какие роуты используются для категорий и постов в этом блоге. Всё очень просто:

Route::get('/{alias}', 'CategoryController@category');
Route::get('/{category}/{alias}', 'PostsController@post');

Обратите внимание на второй роут: мы просто прописали шаблон: слег, альяс категории, слег, альяс поста. Названия переменных могут быть любыми, само собой.

Where в Route, что это и как его использовать?

Самые догадливые уже поняли, что это чертовски напоминает обычные регулярные выражения в PHP. И действительно, то, что мы ищем в URI можно задавать не только с помощью фигурных скобок. Но и всячески фильтровать и сравнивать с практически любыми шаблонами.

Давайте предположим, что у нас есть пользователи. Но мы хотим, чтобы доступ к их страницам был только по их ID (целочисленные идентификаторы). И адреса этих страниц должны выглядеть как /user/1, user/2/, /user/777

В таком случае наша конструкция с фигурными скобками не подойдет. Она позволит задать адрес /user/test, а это не выходит в наши планы. Вернее - ее нужно будет немного доработать. Тогда нам понадобится следующий способ записи роута:

Route::get('user/{id}', 'UsersController@profile')->where('id', '[0-9]+');

Обратите внимание: мы дописали вызов метода where. В качестве первого параметра мы передаем ему имя переменной, которая будет содержать ID пользователя (id). В качестве второго значения мы передаем ему обычное регулярное выражение на PHP, которое является шаблоном. Если проверка не будет пройдена (значение id не попадает под этот шаблон), то этот роут не будет использован и Laravel перейдет к следующему роуту.

В нашем случае, как я уже и сказал, мы проверяем только на "является ли id числом?", но условия проверки могут быть самые любопытные.

Использование роутов в шаблонах (route blade view) или именование роутов (route name)

В самом начале статьи я привел пример именованного роута (route name), но там не объяснил, что именно это значит и зачем это использовать. Пришло время объяснить.

Чтобы было совсем понятно, давайте воспользуемся не тем роутом, а новым, который мы сделали для пользователя и сразу же добавим ему имя:

Route::get('user/{id}', 'UsersController@profile')->where('id', '[0-9]+')->name('profile');

Как вы уже догадались, чтобы дать роуту имя, нужно применить метод name и в качестве параметра указать строку-название этого роута. Она может быть произвольной, но желательно применять к ней те же правила, что и к переменным.

Теперь представим, что мы пишем blade-шаблон и забыли какой именно URI был прописан в нашем роуте, но мы точно помним его название (name) роута - "profile". Мы легко и быстро можем получить URL по имени роута, не прописывая этот URL "жестко"! Для этого достаточно вызвать следующую функцию-хелпер из шаблона:

route('profile', ['id' => 423]);

И она вернем там не только URL, но и самостоятельно подставит ID пользователя. Причем не куда попало, а именно в то место, где мы задали его в первом параметре для Route::get. В результате мы получим следующий URL:

/user/423

Я настоятельно рекомендую использовать эту функцию. Она крайне полезна в том смысле, что позволяет поменять ссылки на пользователей на всём сайте, изменив только сам роут в web.php. В противном случае поиск всех ссылок и их замена может быть довольно мучительна, когда ваш проект станет достаточно большим.

Как получить список роутов (route list)?

Бывают ситуации, когда вам не очевидно, какие именно роуты есть в вашем проекте. Например, это просто не ваш проект, а проект заказчика. В таком случае очень помогает artisan, который всегда готов показать нам вообще все возможные роуты в проекте.

Как вы помните, artisan - это консольная команда Laravel, которая может много разных полезных штук. Так как это консольная команда, вам нужно открыть консоль и перейти в корень вашего проекта. Я не знаю, где находится ваш проект и в какой системе вы работаете, но я работаю в Linux и мой проект находится в каталоге /home/www/laravel/public_html

Поэтому сначала я перейду в этот каталог:

cd /home/www/laravel/public_html

В общем и целом, нам нужно запустить artisan с параметром route:list, именно эта штука покажет нам все роуты. Давайте сделаем это:

$ php artisan route:list

Вывод этой команды представляет из собой таблицу, в которой перечислены все наши маршруты. Она состоит из следующих колонок: домен (domain), метод (method), URI, название (name), action (действие), Middleware (миддлвейр на этом роуте, об этом позже).

Домен - это домен проекта, к котором относится роут. Если вы не знали, то одно приложение Laravel может отвечать за несколько доменов сразу, именно в этом случае это поле будет заполнено. В 99% случаев оно пустое.

Метод - это каким именно образом сделан HTTP-запрос. Например, GET, POST, PUT и другие. В этой статье мы пока что использовали только метод GET. Но обычно в таблице он обозначается как GET|HEAD, т.к. с некоторого времени эти методы являются синонимами.

URI - про него сказано уже достаточно. Здесь это первый параметр из Route::get(), то есть шаблон URI, который мы используем для роута.

Name - это имя роута, как раз то самое, которое мы задали для страницы пользователя с помощью ->name('profile').

Action - название контроллера и метода в нем, к которому будет идти обращение для обработки этого роута. Кстати, если вы использовали Route::resource (о котором позже), вы можете заметить, что он как бы "раскрылся" и все равно указывает на конкретные методы в контроллере. Никакой магии, но сплошное удобство!

Middleware - грубо говоря "код", который вызывается "в промежутке" между вызовом роута и вызовом кода, который должен его обработать. Я расскажу подробнее ниже, но приведу пару примеров. Например, вы не хотите давать доступ к этому адресу не авторизованным пользователям. Или вы не хотите, чтобы этот адрес можно было запросить чаще, чем раз в 30 секунд.

Кеширование роутов (route cache) в Laravel

Иногда Laravel ведет себя неочевидно для программиста-новичка: вроде бы вы добавили новые роуты, но почему-то при попытке открыть страницу по этим адресам - она не найдена или происходит что-то странное.

Поэтому я не могу не упомянуть про кеширование роутов. Laravel делает его самостоятельно, но мы можем им немного управлять - хотя бы сбросить кеш. Для того, чтобы это сделать, нам опять понадобится artisan. Команда выглядит следующим образом:

php artisan route:cache

Пусть вас не смущает отсутствие слова "clear" или ему подобных - эта команда действительно сбрасывает кеш роутов.

Но иногда может происходить неприятное. И скорее всего произойдет. Дело в том, что для кеширования Laravel пытается сериализовать код роутов. Но с определенной версии PHP нельзя сериализовывать замыкания. Таким образом мы видим ошибку:

Unable to prepare route ... for serialization. Uses Closure.

Где вместо трех точек вы сможете увидеть название роута, с которым происходит проблема. Сам же роут обычно выглядит примерно следующим образом:

Route::get('/route', function () {
    // ваш код
});

Обратите внимание: функция без имени (function()) и является замыканием. А так как сериализовать его невозможно, возникает ошибка. Именно поэтому я не приводил в примерах подобных роутов, а сразу показывал как указать на метод контроллера. Здесь нужно сделать то же самое - перенести код из замыкания в метод контроллера и переписать правило каким-то таким образом: Route::get('/route', 'YourController@yourMethod');

POST-метод в роутах (route post) и отправка формы

Теперь предлагаю кратко рассмотреть post-запросы и то, как мы можем обрабатывать их с помощью роутов. Здесь ситуация немного другая, чем с get-запросом, так как всё, что к нам пришло из формы мы будем получать не так, как раньше.

Предположим, что у нас есть форма с одним полем, которая отправляет данные из этого поля методом POST по адресу /setname. Пускай ее предназначение - установить имя пользователя, поэтому передаваемый параметр будет называться name. Давайте взглянем на форму:


<form action="/setname" method="post">
    <input name="name" type="text" />
    <input type="submit" />
</form>

Теперь нам нужно прописать роут для ее обработки:

Route::post("/setname", "UserController@setName");

Здесь пока что всё понятно. Вместо метода get мы использовали метод post. Кроме того, мы не передаем никакие параметры в самом URL, а значит переменных в фигурных скобках у нас нет.

А вот и метод для обработки всего этого дела:

...
use Illuminate\Http\Request;
class UserController extends Controller{
...
	public function setName(Request $request){
		// получение поля name из формы:
		$name = $request->get("name");
	}
...
}

Теперь видна большая разница, по сравнению с GET-запросом. Чтобы получить переданные данные из POST-запроса сначала мы получаем экземпляр класса Illuminate\Http\Request под именем $request.

Вставить его таким образом в наш код (как параметр метода) позволяет специальный механизм под названием Dependency Injection, о котором я не буду сейчас говорить, но настоятельно рекомендую почитать самостоятельно.

Как видно из кода, чтобы получить конкретное значение конкретного поля, нужно вызвать $request->get() и передать ему имя параметра, значение которого мы хотим получить.

Middleware в роутах (route) в Laravel 5

Давайте коротко рассмотрим, как применить middleware в роуте таким образом, чтобы он сработал. О том, что такое middleware я рекомендую почитать официальный мануал или другие источники, у меня пока такой статьи нет, к сожалению.

Я предпочел бы рассмотреть классический случай, когда доступ пользователя к какой-то странице ограничен. Например, если он не оплатил доступ к вашей книге по программированию, то он не может попасть на страницу, где можно ее скачать.

Самый простой вариант будет выглядеть так. Несколько более сложный мы рассмотрим ниже. Итак, код:

use App\Http\Middleware\UserPayed;
Route::get('/book', 'BookController@showDownloadLink')->middleware(UserPayed::class);

Первое, что мы сделали, и чего не делали до этого - мы объявили, что будем использовать класс App\Http\Middleware\UserPayed. Это наш middleware. Далее, мы вызвали дополнительный метод Route::middleware у класса Route с тем, чтобы применить этот middleware.

Таким образом, на "пути" от запроса этого роута и до обработки его методом showDownloadLink контроллера BookController, пользователь "пройдет" через middleware UserPayed. В случае, если доступа у него нет, управление полностью передается в UserPayed и обрабатывается так как нужно. В случае, если доступ у пользователя есть - управление передается методу контроллера, как и было бы в общем случае.

Группировка роутов (route group) в Laravel 5

Но более интересным случаем является другой - написание своей админки для Laravel. Обычная ситуация там следующая: у нас есть админский раздел, все его адреса начинаются (обычно) с префикса /admin (например: /admin/pages?filter=active). И при этом нам нужно знать, есть ли у пользователя доступ туда или нет.

Laravel предоставляет нам удобный способ и то и другое, не тратя много сил и нервов на рефакторинг после. Давайте рассмотрим группировку роутов одновременно с применением middleware, защищающего закрытые разделы сайта.

Route::group(['middleware' => ['IsAdmin'], 'prefix' => '/admin'], function () {
    Route::get('/', 'IndexController@index');
    Route::get('/pages', 'PagesController@index');
    Route::get('/posts', 'PagesController@index');
}

Что тут происходит?

  • Мы сказали Laravel, что собираемся объявить группу роутов. Это делается с помощью Route::group(). В качестве первого аргумента передается массив параметров, он может быть пустым.
  • Вторым аргументов идет замыкание (анонимная функция). Именно в ее теле мы прописываем привычные нам роуты для GET- или POST- (или других) запросов.
  • Внутри мы определяем три "обычных" роута: роут индексиной страницы админки, страницу со списком страниц и страницу со списком постов.
  • В качестве параметра для Route::group мы передаем массив, состоящий из двух значений. В первом мы указываем, через какие middleware должен пройти запрос перед выводом. И это тоже массив (['IsAdmin']). То есть передать можно несколько разных middleware.
  • Во втором мы указываем префикс. Префикс означает, что все вложенные роуты будут начинаться со значения префикса. То есть на деле наши роуты внутри будут работать не по адресам /, /pages и /posts, а по адресам /admin, /admin/pages, /admin/posts.

Такая комбинация крайне удобна. Но есть еще одно, что хотелось бы заметить. Можно добавить еще кое-что.

Добавление Namespace к Route в Laravel

Мы можем также добавить очень полезную штуку - указать, где именно будут лежать классы, которые стоило бы вызвать при обращении к Route::group. Отвлекусь и немного объясню: представим, что ваш сайт состоит из двух больших разделов: внешней части (фронта), которая видна пользователю. Например, там интернет-магазин. И внутренней части (админки), которая видна, разумеется, только админу и менеджерам.

В таком случае хранить все контроллеры в каталоге App\Http\Controllers было бы довольно неудобно, файлов могло бы быть очень много и, со временем, работать с ними стало бы затруднительно.

Я предложил бы решение, которое первым приходит на ум. Разделить их по подкаталогам. Например, все, что относится к "фронту" мы положим в каталог \App\Http\Controllers\Frontend, а всё, что относится к админке положим в каталог \App\Http\Controllers\Backend.

То есть теперь у нас может быть одинаково названный IndexController для фронта (например, главная страница магазина) и так же названный IndexController для админки (главная страница админки). Мы будем понимать, что он отвечает за главную страницу. Просто лежать они будут в разных каталогах. А проситекающее отсюда следствие, и ключевое для нас, - у них будут разные неймспейсы (namespace).

Ларавел может помочь нам объединить всё это воедино. Представим, что у нас есть только два IndexController, с методами index() в каждом (отвечаю за главную страницу сайта и админки соответственно). Теперь мы можем написать следующее:

Route::group(['namespace' => 'Frontend'], function () {
    Route::get('/', 'IndexController@index');
}

Route::group(['namespace' => 'Backend', 'middleware' => ['IsAdmin'], 'prefix' => '/admin'], function () {
    Route::get('/', 'IndexController@index');
}

Всё готово! Вы можете наполнять ваши роуты дальше, не переживая не за префикс, ни за авторизацию и даже не переживая о том, где Laravel будет пытаться искать ваши контроллеры.

Давайте объясню подробнее.

Наш контроллер для сайта лежит в каталоге App/Http/Controllers/Frontend/IndexController.php, поэтому в первой группе роутов мы указали соответствующий namespace. Больше нам ничего не требуется - адрес этой страницы не начинается с префикса и должен пускать всех пользователей. Поэтому мы так это и оставим.

Второй же Route::group содержит адреса админки. Туда мы должны пускать только авторизованных пользователей. Все адреса там начинаются с /admin и, кроме того, все контроллеры лежат в каталоге App/Http/Controllers/Backend/ (как и наш IndexController.php). С помощью параметра "namespace" мы указали, что искать контроллеры нужно именно по этому адресу, а всё остальное я объяснил выше.

Что такое Route Resource в Laravel?

Это такая штука, которая позволяет нам использовать стандартные пути и названия методов для создания CRUD-форм (Create, Read, Update, Delete). Эти формы всем известны: когда вы создаете, например, товар в админке, вы можете как минимум: создать его (когда его еще нет), отредактировать его (когда он уже был создан) и удалить его (когда он уже существует). В некоторых случаях вы можете посмотреть информацию о нем (Read из слова CRUD). Иногда этот метод отвечает за что-то другое.

В любом случае, "ресурс" позволяет здорово экономить строчки кода и стандартизировать свое приложение. Записывается он следующим образом:

Route::resource('posts, 'PostsController');

Помните результат вывода команды, которую мы обсуждали несколько выше?

php artisan route:list

Вот какие роуты создаст метод Route::resource(). По порядку: тип запроса, URI, метод указанного контроллера (тут - PostsController), Имя роута (заданного с помощью метода name()):

GET /photos index photos.index
GET	/photos/create	create	photos.create
POST	/photos	store	photos.store
GET	/photos/{photo}	show	photos.show
GET	/photos/{photo}/edit	edit	photos.edit
PUT/PATCH	/photos/{photo}	update	photos.update
DELETE	/photos/{photo}	destroy	photos.destroy

Обратите внимание, что в общем-то, он скорее похож на REST API, чем на админку. Потому, что на вход он ожидает PUT и DELETE HTTP-заголовки. Тем не менее, он вполне подходит и для админки.

Еще обращаю ваше внимание на то, что метод create(), который он подразумевает в нашем контроллере - это отображение формы создания, но еще не само создание. А вот метод POST /photos - это как раз создание (то есть отправка заполненной формы из метода create() на сервер). Аналогично и с редактированием.

Что еще может быть полезно в роутах? Я хотел бы дополнить статью несколькими полезными советами далее.

Авторизационный роут (auth route) в Laravel

Как некоторые знают, и что не является темой данной статьи, Laravel имеет встроенную работу с пользователями "из коробки". Она добавляется с помощью команды:

php artisan make:auth

И таким образом мы сразу же получаем работу с пользователями, и писать нам это не нужно.

Но иногда бывает, что мы хотим, например, закрыть регистрацию пользователей. В случае, если регистрация не предполагается вообще и только администратор может добавлять пользователей через админку.

В таком случае вместо стандартных роутов от авторов Laravel мы можем добавить свои собственные. В общем-то, не сложно догадаться, что посмотреть все роуты авторизации можно с помощью команды:

php artisan route:list

и найти их вручную. Но я приведу готовый пример, который используется на одном из моих проектов именно для такого случая. Вот он:

Route::group(['namespace' => 'Auth'], function () {
    Route::get('/login', 'LoginController@showLoginForm')->name('login');
    Route::post('/login', 'LoginController@login');
    Route::get('/logout', 'LoginController@logout')->name('logout');
});

Обратите внимание, что я сохранил стандартную авторизацию, указав namespace до классов авторизации. Таким образом, всё работает как и раньше, за исключением того, что по URL-адресам регистрации и восстановления пароля теперь физически пройти нельзя, т.к. таких роутов просто нет.

Как узнать текущий роут (current route) в Laravel?

Обычно проблема заключается не в том, чтобы узнать текущий роут, это описывает официальная документация. Обычно проблема заключается в том, как узнать путь роута, на котором находится пользователь в данный момент.

На самом деле это не такая уж и проблема и делается это с помощью следующего кода:

Route::getCurrentRoute()->getPath();

Вы можете посмотреть Facade класса Route, чтобы самостоятельно узнать, что именно и как он может делать, часто это бывает очень полезно.

Я потратил на написание этой статьи около пяти часов. Надеюсь она была вам помогла. Удачи!

Комментарии

  • Andrei Grechishnikov - 10 months ago
    Спасибо большое.Все очень доходчиво и четко.

Обязательное поле.
Подсказка по Markdown, используется для оформления.

DeveloperNotes.ru © 2018 — 2020