Verification: a143cc29221c9be0

Php artisan route list без middleware

Php artisan route list без middleware

Контроллер CategoryController

Теперь поработаем над панелью управления магазином. И начнем с категорий каталога товаров. Нам нужен ресурсный контроллер, т.е. контроллер, который позволяет выполянить CRUD-операции над категориями каталога. Создать такой контроллер можно с помощью artisan-команды.

> php artisan make:controller Admin/CategoryController --resource
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

class CategoryController extends Controller {
    public function index() {
        // ...
    }

    public function create() {
        // ...
    }

    public function store(Request $request) {
        // ...
    }

    public function show($id) {
        // ...
    }

    public function edit($id) {
        // ...
    }

    public function update(Request $request, $id) {
        // ...
    }

    public function destroy($id) {
        // ...
    }
}

Но можно поступить лучше — сразу указать модель, с которой будет работать контроллер:

> php artisan make:controller Admin/CategoryController --resource --model=Models/Category
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Category;
use Illuminate\Http\Request;

class CategoryController extends Controller {
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index() {
        // ...
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create() {
        // ...
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request) {
        // ...
    }

    /**
     * Display the specified resource.
     *
     * @param  \App\Models\Category  $category
     * @return \Illuminate\Http\Response
     */
    public function show(Category $category) {
        // ...
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  \App\Models\Category  $category
     * @return \Illuminate\Http\Response
     */
    public function edit(Category $category) {
        // ...
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Models\Category  $category
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, Category $category) {
        // ...
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  \App\Models\Category  $category
     * @return \Illuminate\Http\Response
     */
    public function destroy(Category $category) {
        // ...
    }
}

Семь маршрутов для CRUD

Теперь для каждого экшена нам нужен маршрут — всего семь маршрутов. Это можно сделать с помощью одной строки кода.

/*
Тип        URI              Действие  Имя маршрута
--------------------------------------------------
GET        /item            index     item.index
GET        /item/create     create    item.create
POST       /item            store     item.store
GET        /item/{id}       show      item.show
GET        /item/{id}/edit  edit      item.edit
PUT/PATCH  /item/{id}       update    item.update
DELETE     /item/{id}       destroy   item.destroy
*/
Route::resource('item', 'ItemController');

В нашем случае будет немного сложнее — потому что нужна группировка + защита маршртутов с помощью middleware.

Route::group([
    'as' => 'admin.', // имя маршрута, например admin.index
    'prefix' => 'admin', // префикс маршрута, например admin/index
    'namespace' => 'Admin', // пространство имен контроллера
    'middleware' => ['auth', 'admin'] // один или несколько посредников
], function () {
    // главная страница панели управления
    Route::get('index', 'IndexController')->name('index');
    // CRUD-операции над категориями каталога
    Route::resource('category', 'CategoryController');
});

Проверить маршруты можно с помощью artisan-команды:

> php artisan route:list --name=category 
+-----------+--------------------------------+------------------------+-------------------------------------------------------+------------+
| Method    | URI                            | Name                   | Action                                                | Middleware |
+-----------+--------------------------------+------------------------+-------------------------------------------------------+------------+
| GET|HEAD  | admin/category                 | admin.category.index   | App\Http\Controllers\Admin\CategoryController@index   | .......... |
| GET|HEAD  | admin/category/{category}      | admin.category.show    | App\Http\Controllers\Admin\CategoryController@show    | .......... |
| GET|HEAD  | admin/category/create          | admin.category.create  | App\Http\Controllers\Admin\CategoryController@create  | .......... |
| POST      | admin/category                 | admin.category.store   | App\Http\Controllers\Admin\CategoryController@store   | .......... |
| GET|HEAD  | admin/category/{category}/edit | admin.category.edit    | App\Http\Controllers\Admin\CategoryController@edit    | .......... |
| PUT|PATCH | admin/category/{category}      | admin.category.update  | App\Http\Controllers\Admin\CategoryController@update  | .......... |
| DELETE    | admin/category/{category}      | admin.category.destroy | App\Http\Controllers\Admin\CategoryController@destroy | .......... |
| GET|HEAD  | catalog/category/{slug}        | catalog.category       | App\Http\Controllers\CatalogController@category       | .......... |
+-----------+--------------------------------+------------------------+-------------------------------------------------------+------------+

Реализуем метод index()

Хорошо, давайте реализуем метод index() контроллера, который будет отвечать за показ всех категорий.

class CategoryController extends Controller {
    /* ... */
    public function index() {
        $roots = Category::roots();
        return view('admin.category.index', compact('roots'));
    }
    /* ... */
}

И создадим шаблон index.blade.php в директории views/admin/category:

@extends('layout.admin')

@section('content')
    

Все категории class="table table-bordered"> @include('admin.category.part.tree', ['items' => $roots, 'level' => -1])
width="30%">Наименование width="65%">Описание class="fas fa-edit"> class="fas fa-trash-alt">
@endsection

Шаблон tree.blade.php в директории views/admin/category/part подключает сам себя для рекурсивного вывода всех категорий.

@if (count($items))
    @php
        $level++;
    @endphp
    @foreach ($items as $item)
        

                @if ($level)
                    {{ str_repeat('—', $level) }}
                @endif
                href="{{ route('admin.category.show', ['category' => $item->id]) }}"
                   style="font-weight:@if($level) normal @else bold @endif">
                    {{ $item->name }}
                
            

            
{{ iconv_substr($item->content, 0, 150) }}

            
                href="{{ route('admin.category.edit', ['category' => $item->id]) }}">
                    class="far fa-edit">
                
            

            
                
action
="{{ route('admin.category.destroy', ['category' => $item->id]) }}" method="post"> @csrf @method('DELETE') ="submit" class="m-0 p-0 border-0 bg-transparent"> class="far fa-trash-alt text-danger">
@if ($item->children->count()) @include('admin.category.part.tree', ['items' => $item->children, 'level' => $level]) @endif @endforeach @endif

Реализуем метод show()

Теперь реализуем метод show() контроллера, который будет отвечать за показ выбранной категории.

class CategoryController extends Controller {
    /* ... */
    public function show(Category $category) {
        return view('admin.category.show', compact('category'));
    }
    /* ... */
}

И создадим шаблон show.blade.php в директории views/admin/category:

@extends('layout.admin')

@section('content')
    

Просмотр категории
class="row">
class="col-md-6">

Название: {{ $category->name }}

ЧПУ (англ): {{ $category->slug }}

Краткое описание @isset($category->content)

{{ $category->content }} @else

Описание отсутствует @endisset
class="col-md-6"> src="https://via.placeholder.com/600x200" alt="" class="img-fluid">
@if ($category->children->count())

Дочерние категории class="table table-bordered"> @foreach($category->children as $child)@endforeach
width="45%">Наименование width="45%">ЧПУ (англ) class="fas fa-edit"> class="fas fa-trash-alt">
{{ $loop->iteration }} href="{{ route('admin.category.show', ['category' => $child->id]) }}"> {{ $child->name }} {{ $child->slug }} href="{{ route('admin.category.edit', ['category' => $child->id]) }}"> class="far fa-edit">
action
="{{ route('admin.category.destroy', ['category' => $child->id]) }}" method="post"> @csrf @method('DELETE') ="submit" class="m-0 p-0 border-0 bg-transparent"> class="far fa-trash-alt text-danger">
@else

Нет дочерних категорий @endif
method
="post" action="{{ route('admin.category.destroy', ['category' => $category->id]) }}"> @csrf @method('DELETE') ="submit" class="btn btn-danger"> Удалить категорию @endsection

Введение

Вместо того, чтобы определять всю логику обработки запросов как замыкания в файлах маршрутов, вы можете организовать это поведение с помощью классов «контроллеров». Контроллеры могут сгруппировать связанную логику обработки запросов в один класс. Например, класс UserController может обрабатывать все входящие запросы, относящиеся к пользователям, включая отображение, создание, обновление и удаление пользователей. По умолчанию контроллеры хранятся в каталоге app/Http/Controllers.

Написание контроллеров

Основные понятия о контроллерах

Давайте посмотрим на отвлеченный пример контроллера. Обратите внимание, что он расширяет базовый класс контроллера App\Http\Controllers\Controller, включенный в Laravel:

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Models\User;

class UserController extends Controller
{
    
    public function show($id)
    {
        return view('user.profile', [
            'user' => User::findOrFail($id)
        ]);
    }
}

Вы можете определить маршрут к этому методу контроллера следующим образом:

use App\Http\Controllers\UserController;

Route::get('/user/{id}', [UserController::class, 'show']);

Когда входящий запрос совпадает с указанным URI маршрута, будет вызван метод show класса App\Http\Controllers\UserController, и параметры маршрута будут переданы методу.

Контроллеры не требуют расширения базового класса. Однако у вас не будет доступа к удобным функциям, таким как методы middleware иauthorize.

Контроллеры одиночного действия

Если действие контроллера является особенно сложным, вам может показаться удобным посвятить целый класс контроллера этому единственному действию. Для этого вы можете определить один метод __invoke в контроллере:

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Models\User;

class ProvisionServer extends Controller
{
    
    public function __invoke()
    {
        
    }
}

При регистрации маршрутов для контроллеров одиночного действия вам не нужно указывать метод контроллера. Вместо этого вы можете просто передать маршрутизатору имя контроллера:

use App\Http\Controllers\ProvisionServer;

Route::post('/server', ProvisionServer::class);

Вы можете сгенерировать вызываемый контроллер, используя параметр --invokable команды make:controller Artisan:

php artisan make:controller ProvisionServer --invokable
Заготовки контроллера можно настроить с помощью публикации заготовок.

Посредник контроллера

Посредник может быть назначен маршрутам контроллера в ваших файлах маршрутизации:

Route::get('profile', [UserController::class, 'show'])->middleware('auth');

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

class UserController extends Controller
{
    
    public function __construct()
    {
        $this->middleware('auth');
        $this->middleware('log')->only('index');
        $this->middleware('subscribed')->except('store');
    }
}

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

$this->middleware(function ($request, $next) {
    return $next($request);
});

Ресурсные контроллеры

Если вы думаете о каждой модели Eloquent в вашем приложении как о «ресурсе», то для каждого ресурса в вашем приложении обычно выполняются одни и те же наборы действий. Например, представьте, что ваше приложение содержит модель Photo и модель Movie. Вполне вероятно, что пользователи могут создавать, читать, обновлять или удалять эти ресурсы.

Благодаря такому распространенному варианту использования, маршрутизация ресурсов Laravel присвоит типичные маршруты создания, чтения, обновления и удаления («CRUD») контроллеру с помощью одной строки кода. Для начала мы можем использовать параметр --resource команды make:controller Artisan, чтобы быстро создать контроллер для обработки этих действий:

php artisan make:controller PhotoController --resource

Эта команда поместит новый класс контроллера в каталог app/Http/Controllers вашего приложения. Контроллер будет содержать метод для каждого из доступных действий с ресурсами. Затем, вы можете зарегистрировать маршрут ресурса, который указывает на контроллер:

use App\Http\Controllers\PhotoController;

Route::resource('photos', PhotoController::class);

Это единое определение маршрута создаст несколько маршрутов для обработки множества действий с ресурсом. Сгенерированный контроллер уже будет иметь заготовки для каждого из этих действий. Помните, вы всегда можете получить быстрый обзор маршрутов своего приложения, выполнив команду route:list Artisan.

Вы даже можете зарегистрировать сразу несколько контроллеров ресурсов, передав массив методу resources:

Route::resources([
    'photos' => PhotoController::class,
    'posts' => PostController::class,
]);

Действия, выполняемые ресурсными контроллерами

Метод URI Действие Имя маршрута
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

Настройка поведения при отсутствии модели

Обычно, если неявно связанная модель ресурса не найдена, то генерируется HTTP-ответ с кодом 404. Однако вы можете изменить это поведение, вызвав метод missing при определении вашего ресурсного маршрута. Метод missing принимает замыкание, которое будет вызываться, если неявно связанная модель не может быть найдена для любого из маршрутов ресурса:

use App\Http\Controllers\PhotoController;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redirect;

Route::resource('photos', PhotoController::class)
        ->missing(function (Request $request) {
            return Redirect::route('photos.index');
        });

Указание модели ресурса

Если вы используете привязку модели к маршруту и хотите, чтобы методы контроллера ресурса содержали типизацию экземпляра модели, вы можете использовать параметр --model при создании контроллера:

php artisan make:controller PhotoController --resource --model=Photo

Частичные ресурсные маршруты

При объявлении маршрута ресурса вы можете указать подмножество действий, которые должен обрабатывать контроллер, вместо полного набора действий по умолчанию:

use App\Http\Controllers\PhotoController;

Route::resource('photos', PhotoController::class)->only([
    'index', 'show'
]);

Route::resource('photos', PhotoController::class)->except([
    'create', 'store', 'update', 'destroy'
]);

Ресурсные API-маршруты

При определении маршрутов ресурса, которые будут использоваться API, бывает необходимо исключить маршруты, содержащие ответы с HTML-шаблонами, такие как create и edit. Для удобства вы можете использовать метод apiResource, чтобы автоматически исключить эти два маршрута:

use App\Http\Controllers\PhotoController;

Route::apiResource('photos', PhotoController::class);

Вы можете зарегистрировать сразу несколько ресурсных API-контроллеров, передав массив методу apiResources:

use App\Http\Controllers\PhotoController;
use App\Http\Controllers\PostController;

Route::apiResources([
    'photos' => PhotoController::class,
    'posts' => PostController::class,
]);

Чтобы быстро сгенерировать ресурсный API-контроллер, который не включает методы create или edit, используйте переключатель --api при выполнении команды make:controller:

php artisan make:controller PhotoController --api

Вложенные ресурсы

Иногда требуется определить маршруты ко вложенному ресурсу. Например, фоторесурс может иметь несколько комментариев, которые могут быть прикреплены к фотографии. Чтобы вложить ресурсные контроллеры, используйте «точечную нотацию» в определении маршрута:

use App\Http\Controllers\PhotoCommentController;

Route::resource('photos.comments', PhotoCommentController::class);

Этот маршрут зарегистрирует вложенный ресурс, к которому можно получить доступ с помощью URI, подобных следующим:

/photos/{photo}/comments/{comment}

Ограничение вложенных ресурсов

Функционал неявной привязки модели Laravel может автоматически ограничивать вложенные привязки для подтверждения принадлежности извлеченной дочерней модели по отношению к родительской модели. Используя метод scoped при определении вашего вложенного ресурса, вы можете включить автоматическое ограничение, а также указать Laravel, через какое поле дочерний ресурс должен быть получен. Для получения дополнительных сведений о том, как это сделать, смотрите документацию по ограничению ресурсных маршрутов.

Упрощенное вложение

Часто нет необходимости иметь в URI и родительский, и дочерний идентификаторы, поскольку дочерний идентификатор уже является уникальным идентификатором. При использовании уникальных идентификаторов, таких как автоинкрементные первичные ключи, для идентификации ваших моделей в сегментах URI, вы можете использовать «упрощенное вложение»:

use App\Http\Controllers\CommentController;

Route::resource('photos.comments', CommentController::class)->shallow();

Это объявление маршрута будет определять следующие маршруты:

Метод URI Действие Имя маршрута
GET /photos/{photo}/comments index photos.comments.index
GET /photos/{photo}/comments/create create photos.comments.create
POST /photos/{photo}/comments store photos.comments.store
GET /comments/{comment} show comments.show
GET /comments/{comment}/edit edit comments.edit
PUT/PATCH /comments/{comment} update comments.update
DELETE /comments/{comment} destroy comments.destroy

Именование ресурсных маршрутов

По умолчанию все действия ресурсного контроллера имеют имя маршрута; однако, вы можете переопределить эти имена, передав массив имен с желаемыми именами маршрутов:

use App\Http\Controllers\PhotoController;

Route::resource('photos', PhotoController::class)->names([
    'create' => 'photos.build'
]);

Именование параметров ресурсных маршрутов

По умолчанию Route::resource создаст параметры маршрута для ваших ресурсных маршрутов на основе «сингулярной» версии имени ресурса. Вы можете легко переопределить это для каждого ресурса, используя метод parameters. Массив, передаваемый в метод parameters, должен быть ассоциативным массивом имен ресурсов и имен параметров:

use App\Http\Controllers\AdminUserController;

Route::resource('users', AdminUserController::class)->parameters([
    'users' => 'admin_user'
]);

В приведенном выше примере создается следующий URI для маршрута show ресурса:

/users/{admin_user}

Ограничение ресурсных маршрутов

Функционал ограничения неявной привязки модели Laravel может автоматически ограничивать вложенные привязки для подтверждения принадлежности извлеченной дочерней модели по отношению к родительской модели. Используя метод scoped при определении вашего вложенного ресурса, вы можете включить автоматическое ограничение, а также указать Laravel, через какое поле дочерний ресурс должен быть получен:

use App\Http\Controllers\PhotoCommentController;

Route::resource('photos.comments', PhotoCommentController::class)->scoped([
    'comment' => 'slug',
]);

Этот маршрут зарегистрирует ограниченный вложенный ресурс, к которому можно получить доступ с помощью таких URI, как следующий:

/photos/{photo}/comments/{comment:slug}

При использовании пользовательской неявной привязки с ключом в качестве параметра вложенного маршрута, Laravel автоматически задает ограничение для получения вложенной модели своим родителем, используя соглашения, чтобы угадать имя отношения родительского элемента. В этом случае предполагается, что модель Photo имеет отношение с именем comments (множественное число от имени параметра маршрута), которое можно использовать для получения модели Comment.

Локализация URI ресурсов

По умолчанию Route::resource создает URI ресурсов с использованием английских глаголов. Если вам нужно локализовать команды действия create и edit, вы можете использовать метод Route::resourceVerbs. Это можно сделать в начале метода boot внутри App\Providers\RouteServiceProvider вашего приложения:


public function boot()
{
    Route::resourceVerbs([
        'create' => 'crear',
        'edit' => 'editar',
    ]);

    
}

После того, как глаголы были скорректированы, регистрация маршрута ресурса, например, Route::resource('fotos', PhotoController::class), создаст следующие URI:

/fotos/crear

/fotos/{foto}/editar

Дополнение ресурсных контроллеров

Если вам нужно добавить дополнительные маршруты ресурсного контроллера помимо набора ресурсных маршрутов по умолчанию, вы должны определить эти маршруты перед вызовом метода Route::resource; в противном случае маршруты, определенные методом resource, могут непреднамеренно иметь приоритет над вашими дополнительными маршрутами:

use App\Http\Controller\PhotoController;

Route::get('/photos/popular', [PhotoController::class, 'popular']);
Route::resource('photos', PhotoController::class);
Помните, что ваши контроллеры должны быть сосредоточенными. Если вам постоянно требуются методы, выходящие за рамки типичного набора действий с ресурсами, рассмотрите возможность разделения вашего контроллера на два меньших контроллера.

Введение

Посредник обеспечивает удобный механизм для проверки и фильтрации HTTP-запросов, поступающих в ваше приложение. Например, в Laravel уже содержится посредник, проверяющий аутентификацию пользователя вашего приложения. Если пользователь не аутентифицирован, то посредник перенаправит пользователя на экран входа в ваше приложение. Однако, если пользователь аутентифицирован, то посредник позволит запросу продолжить работу в приложении.

Посредник может быть написан для выполнения различных задач помимо аутентификации. Например, посредник для ведения журнала может регистрировать все входящие запросы вашего приложения. В состав фреймворка Laravel уже входят несколько посредников, включая посредник для аутентификации и посредник для защиты от CSRF. Все эти посредники находится в каталоге app/Http/Middleware.

Определение посредника

Чтобы создать нового посредника, используйте команду make:middleware Artisan:

php artisan make:middleware EnsureTokenIsValid

Эта команда поместит новый класс посредника в каталог app/Http/Middleware вашего приложения. В этом посреднике мы будем разрешать доступ к маршруту только в том случае, если значение входящего token соответствует указанному. В противном случае мы перенаправим пользователя по маршруту home:

namespace App\Http\Middleware;

use Closure;

class EnsureTokenIsValid
{
    
    public function handle($request, Closure $next)
    {
        if ($request->input('token') !== 'my-secret-token') {
            return redirect('home');
        }

        return $next($request);
    }
}

Как видите, если переданный token не совпадает с нашим секретным токеном, то посредник вернет клиенту HTTP-перенаправление; в противном случае запрос будет передан в приложение. Чтобы передать запрос дальше в приложение (позволяя «пройти» посредника), вы должны вызвать замыкание $next с параметром $request.

Лучше всего представить себе посредников как серию «слоев» для HTTP-запроса, которые необходимо пройти, прежде чем запрос попадет в ваше приложение. Каждый слой может рассмотреть запрос и даже полностью отклонить его.

Все посредники извлекаются из контейнера служб, поэтому вы можете объявить необходимые вам зависимости в конструкторе посредника.

Посредники и ответы

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

namespace App\Http\Middleware;

use Closure;

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

        return $next($request);
    }
}

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

namespace App\Http\Middleware;

use Closure;

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

        

        return $response;
    }
}

Регистрация посредника

Глобальный стек HTTP-посредников

Если вы хотите, чтобы посредник запускался во время каждого HTTP-запроса к вашему приложению, то укажите класс посредника в свойстве $middleware вашего класса app/Http/Kernel.php.

Назначение посредников маршрутам

Если вы хотите назначить посредника определенным маршрутам, то вам следует сначала зарегистрировать ключ посредника в файле app/Http/Kernel.php вашего приложения. По умолчанию свойство $routeMiddleware этого класса содержит записи для посредников, уже включенных в состав Laravel. Вы можете добавить свой собственный посредник в этот список, и назначить ему ключ по вашему выбору:



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

После того, как посредник был определен в HTTP-ядре, вы можете использовать метод middleware для назначения посредника маршруту:

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

Вы можете назначить несколько посредников маршруту, передав массив имен посредников методу middleware:

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

Вы можете назначить посредника, передав полное имя класса:

use App\Http\Middleware\EnsureTokenIsValid;

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

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

use App\Http\Middleware\EnsureTokenIsValid;

Route::middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/', function () {
        
    });

    Route::get('/profile', function () {
        
    })->withoutMiddleware([EnsureTokenIsValid::class]);
});

Метод withoutMiddleware удаляет только посредника маршрутизации и не применим к глобальному посреднику.

Группы посредников

По желанию можно сгруппировать несколько посредников под одним ключом, чтобы упростить их назначение маршрутам. Вы можете сделать это, используя свойство $middlewareGroups вашего HTTP-ядра.

По умолчанию Laravel поставляется с группами посредников web и api, которые содержат основных посредников, которые вы, возможно, захотите применить к своим веб- и API-маршрутам. Помните, что эти группы посредников автоматически применяются поставщиком служб App\Providers\RouteServiceProvider вашего приложения к маршрутам, определенным в файлах маршрутов web и api, соответственно:


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:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

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

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

Route::middleware(['web'])->group(function () {
    
});
Из коробки группы посредников web и api автоматически применяются к соответствующим файлам вашего приложения routes/web.php и routes/api.php с помощью App\Providers\RouteServiceProvider.

Сортировка посредников

В редких случаях, может понадобиться, чтобы посредники выполнялись в определенном порядке, но вы не можете контролировать их порядок, когда они назначены маршруту. В этом случае вы можете указать приоритет посредников, используя свойство $middlewarePriority вашего файла app/Http/Kernel.php. Это свойство может отсутствовать в вашем HTTP-ядре по умолчанию. Если оно не существует, то вы можете скопировать его определение по умолчанию ниже:


protected $middlewarePriority = [
    \Illuminate\Cookie\Middleware\EncryptCookies::class,
    \Illuminate\Session\Middleware\StartSession::class,
    \Illuminate\View\Middleware\ShareErrorsFromSession::class,
    \Illuminate\Contracts\Auth\Middleware\AuthenticatesRequests::class,
    \Illuminate\Routing\Middleware\ThrottleRequests::class,
    \Illuminate\Session\Middleware\AuthenticateSession::class,
    \Illuminate\Routing\Middleware\SubstituteBindings::class,
    \Illuminate\Auth\Middleware\Authorize::class,
];

Параметры посредника

Посредник также может получать дополнительные параметры. Например, если вашему приложению необходимо проверить, что аутентифицированный пользователь имеет конкретную «роль» перед выполнением им конкретного действия, то вы можете создать посредника, например, EnsureUserHasRole, который получит имя роли в качестве дополнительного аргумента.

Дополнительные параметры посредника будут переданы после аргумента $next:

namespace App\Http\Middleware;

use Closure;

class EnsureUserHasRole
{
    
    public function handle($request, Closure $next, $role)
    {
        if (! $request->user()->hasRole($role)) {
            
        }

        return $next($request);
    }

}

Параметры посредника можно указать при определении маршрута, разделив имя посредника и параметры символом :. Несколько параметров следует разделять запятыми:

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