控制器

简介
编写控制器
- 基础控制器
- 单动作控制器
控制器中间件
- 中间件属性
- 授权属性
资源控制器
依赖注入与控制器

简介

与其将所有的请求处理逻辑定义为路由文件中的闭包，不如使用“控制器”类来组织这些行为。控制器可以将相关的请求处理逻辑归类到一个单独的类中。例如，一个 UserController 类可以处理所有与用户相关的传入请求，包括显示、创建、更新和删除用户。默认情况下，控制器存储在 app/Http/Controllers 目录中。

编写控制器

基础控制器

要快速生成新的控制器，可以运行 make:controller Artisan 命令。默认情况下，应用程序的所有控制器都存储在 app/Http/Controllers 目录中。

1php artisan make:controller UserController

php artisan make:controller UserController

让我们看一个基础控制器的示例。控制器可以包含任意数量的公共方法，这些方法将响应传入的 HTTP 请求。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Models\User;
 6use Illuminate\View\View;
 7 
 8class UserController extends Controller
 9{
10    /**
11     * Show the profile for a given user.
12     */
13    public function show(string $id): View
14    {
15        return view('user.profile', [
16            'user' => User::findOrFail($id)
17        ]);
18    }
19}

<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\View\View;

class UserController extends Controller
{
    /**
     * Show the profile for a given user.
     */
    public function show(string $id): View
    {
        return view('user.profile', [
            'user' => User::findOrFail($id)
        ]);
    }
}

编写完控制器类和方法后，您可以像这样定义指向该控制器方法的路由：

1use App\Http\Controllers\UserController;
2 
3Route::get('/user/{id}', [UserController::class, 'show']);

use App\Http\Controllers\UserController;

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

当传入请求与指定的路由 URI 匹配时，App\Http\Controllers\UserController 类中的 show 方法将被调用，并且路由参数将被传递给该方法。

控制器不需要继承基类。但是，继承包含可在所有控制器中共享的方法的基控制器类有时会很方便。

单动作控制器

如果某个控制器动作特别复杂，您可能会觉得将整个控制器类专门用于该单一动作会更方便。要实现这一点，您可以在控制器中定义一个单独的 __invoke 方法。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5class ProvisionServer extends Controller
 6{
 7    /**
 8     * Provision a new web server.
 9     */
10    public function __invoke()
11    {
12        // ...
13    }
14}

<?php

namespace App\Http\Controllers;

class ProvisionServer extends Controller
{
    /**
     * Provision a new web server.
     */
    public function __invoke()
    {
        // ...
    }
}

为单动作控制器注册路由时，无需指定控制器方法。相反，您只需将控制器名称传递给路由器即可：

1use App\Http\Controllers\ProvisionServer;
2 
3Route::post('/server', ProvisionServer::class);

use App\Http\Controllers\ProvisionServer;

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

您可以使用 make:controller Artisan 命令的 --invokable 选项来生成可调用的控制器。

1php artisan make:controller ProvisionServer --invokable

php artisan make:controller ProvisionServer --invokable

控制器存根（stubs）可以通过发布存根进行自定义。

控制器中间件

中间件可以分配给路由文件中的控制器路由。

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

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

或者，您可能会发现在控制器类中指定中间件更方便。为此，您的控制器应实现 HasMiddleware 接口，该接口规定控制器必须有一个静态的 middleware 方法。在该方法中，您可以返回一个应应用于控制器动作的中间件数组。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Routing\Controllers\HasMiddleware;
 6use Illuminate\Routing\Controllers\Middleware;
 7 
 8class UserController implements HasMiddleware
 9{
10    /**
11     * Get the middleware that should be assigned to the controller.
12     */
13    public static function middleware(): array
14    {
15        return [
16            'auth',
17            new Middleware('log', only: ['index']),
18            new Middleware('subscribed', except: ['store']),
19        ];
20    }
21 
22    // ...
23}

<?php

namespace App\Http\Controllers;

use Illuminate\Routing\Controllers\HasMiddleware;
use Illuminate\Routing\Controllers\Middleware;

class UserController implements HasMiddleware
{
    /**
     * Get the middleware that should be assigned to the controller.
     */
    public static function middleware(): array
    {
        return [
            'auth',
            new Middleware('log', only: ['index']),
            new Middleware('subscribed', except: ['store']),
        ];
    }

    // ...
}

您还可以将控制器中间件定义为闭包，这提供了一种无需编写整个中间件类即可定义内联中间件的便捷方式。

 1use Closure;
 2use Illuminate\Http\Request;
 3 
 4/**
 5 * Get the middleware that should be assigned to the controller.
 6 */
 7public static function middleware(): array
 8{
 9    return [
10        function (Request $request, Closure $next) {
11            return $next($request);
12        },
13    ];
14}

use Closure;
use Illuminate\Http\Request;

/**
 * Get the middleware that should be assigned to the controller.
 */
public static function middleware(): array
{
    return [
        function (Request $request, Closure $next) {
            return $next($request);
        },
    ];
}

中间件属性

您还可以使用 PHP 属性（attributes）将中间件分配给控制器。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Routing\Attributes\Controllers\Middleware;
 6 
 7#[Middleware('auth')]
 8#[Middleware('log', only: ['index'])]
 9#[Middleware('subscribed', except: ['store'])]
10class UserController
11{
12    // ...
13}

<?php

namespace App\Http\Controllers;

use Illuminate\Routing\Attributes\Controllers\Middleware;

#[Middleware('auth')]
#[Middleware('log', only: ['index'])]
#[Middleware('subscribed', except: ['store'])]
class UserController
{
    // ...
}

您也可以将中间件属性放在单个控制器方法上。分配给方法的中间件将与在类级别分配的中间件合并。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Closure;
 6use Illuminate\Http\Request;
 7use Illuminate\Routing\Attributes\Controllers\Middleware;
 8 
 9#[Middleware('auth')]
10class UserController
11{
12    #[Middleware('log')]
13    #[Middleware('subscribed')]
14    public function index()
15    {
16        // ...
17    }
18 
19    #[Middleware(static function (Request $request, Closure $next) {
20        // ...
21 
22        return $next($request);
23    })]
24    public function store()
25    {
26        // ...
27    }
28}

<?php

namespace App\Http\Controllers;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Routing\Attributes\Controllers\Middleware;

#[Middleware('auth')]
class UserController
{
    #[Middleware('log')]
    #[Middleware('subscribed')]
    public function index()
    {
        // ...
    }

    #[Middleware(static function (Request $request, Closure $next) {
        // ...

        return $next($request);
    })]
    public function store()
    {
        // ...
    }
}

授权属性

如果您通过策略（Policies）对控制器动作进行授权，则可以使用 Authorize 属性作为 can 中间件的便捷快捷方式。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Models\Comment;
 6use App\Models\Post;
 7use Illuminate\Routing\Attributes\Controllers\Authorize;
 8 
 9class CommentController
10{
11    #[Authorize('create', [Comment::class, 'post'])]
12    public function store(Post $post)
13    {
14        // ...
15    }
16 
17    #[Authorize('delete', 'comment')]
18    public function destroy(Comment $comment)
19    {
20        // ...
21    }
22}

<?php

namespace App\Http\Controllers;

use App\Models\Comment;
use App\Models\Post;
use Illuminate\Routing\Attributes\Controllers\Authorize;

class CommentController
{
    #[Authorize('create', [Comment::class, 'post'])]
    public function store(Post $post)
    {
        // ...
    }

    #[Authorize('delete', 'comment')]
    public function destroy(Comment $comment)
    {
        // ...
    }
}

第一个参数是您想要授权的能力。第二个参数是应传递给策略的模型类、路由参数或参数。

资源控制器

如果您将应用程序中的每个 Eloquent 模型视为一个“资源”，那么对每个资源执行相同的操作集是很常见的。例如，想象您的应用程序包含 Photo 模型和 Movie 模型。用户很可能能够创建、读取、更新或删除这些资源。

由于这种常见的用例，Laravel 资源路由可以用一行代码将典型的创建、读取、更新和删除（“CRUD”）路由分配给控制器。首先，我们可以使用 make:controller Artisan 命令的 --resource 选项快速创建一个用于处理这些动作的控制器。

1php artisan make:controller PhotoController --resource

php artisan make:controller PhotoController --resource

该命令将在 app/Http/Controllers/PhotoController.php 生成一个控制器。该控制器将为每个可用的资源操作包含一个方法。接下来，您可以注册一个指向该控制器的资源路由。

1use App\Http\Controllers\PhotoController;
2 
3Route::resource('photos', PhotoController::class);

use App\Http\Controllers\PhotoController;

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

这条单一的路由声明创建了多个路由，用于处理资源上的各种动作。生成的控制器将已经为这些动作中的每一个预留了方法存根。请记住，您始终可以通过运行 route:list Artisan 命令快速查看应用程序的路由概况。

您甚至可以通过向 resources 方法传递一个数组，一次性注册多个资源控制器。

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

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

softDeletableResources 方法注册了多个均使用 withTrashed 方法的资源控制器。

1Route::softDeletableResources([
2    'photos' => PhotoController::class,
3    'posts' => PostController::class,
4]);

Route::softDeletableResources([
    '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

自定义缺失模型的行为

通常，如果隐式绑定的资源模型未找到，将生成 404 HTTP 响应。但是，您可以通过在定义资源路由时调用 missing 方法来自定义此行为。missing 方法接受一个闭包，如果无法为资源的任何路由找到隐式绑定的模型，该闭包将被调用。

1use App\Http\Controllers\PhotoController;
2use Illuminate\Http\Request;
3use Illuminate\Support\Facades\Redirect;
4 
5Route::resource('photos', PhotoController::class)
6    ->missing(function (Request $request) {
7        return Redirect::route('photos.index');
8    });

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');
    });

软删除模型

通常，隐式模型绑定不会检索已软删除的模型，而是返回 404 HTTP 响应。但是，您可以通过在定义资源路由时调用 withTrashed 方法来指示框架允许使用软删除模型。

1use App\Http\Controllers\PhotoController;
2 
3Route::resource('photos', PhotoController::class)->withTrashed();

use App\Http\Controllers\PhotoController;

Route::resource('photos', PhotoController::class)->withTrashed();

不带参数调用 withTrashed 将允许 show、edit 和 update 资源路由使用软删除模型。您可以通过向 withTrashed 方法传递数组来指定这些路由的子集。

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

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

指定资源模型

如果您正在使用路由模型绑定，并希望资源控制器的方法对模型实例进行类型提示，您可以在生成控制器时使用 --model 选项。

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

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

生成表单请求

在生成资源控制器时，您可以提供 --requests 选项，以指示 Artisan 为控制器的存储和更新方法生成表单请求类。

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

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

部分资源路由

声明资源路由时，您可以指定控制器应处理的动作子集，而不是完整的默认动作集。

1use App\Http\Controllers\PhotoController;
2 
3Route::resource('photos', PhotoController::class)->only([
4    'index', 'show'
5]);
6 
7Route::resource('photos', PhotoController::class)->except([
8    'create', 'store', 'update', 'destroy'
9]);

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 方法自动排除这两个路由。

1use App\Http\Controllers\PhotoController;
2 
3Route::apiResource('photos', PhotoController::class);

use App\Http\Controllers\PhotoController;

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

您可以通过向 apiResources 方法传递数组，一次性注册多个 API 资源控制器。

1use App\Http\Controllers\PhotoController;
2use App\Http\Controllers\PostController;
3 
4Route::apiResources([
5    'photos' => PhotoController::class,
6    'posts' => PostController::class,
7]);

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

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

要快速生成不包含 create 或 edit 方法的 API 资源控制器，请在执行 make:controller 命令时使用 --api 开关。

1php artisan make:controller PhotoController --api

php artisan make:controller PhotoController --api

嵌套资源

有时您可能需要定义嵌套资源的路由。例如，一个照片资源可能有多个可以附加到该照片的评论。要嵌套资源控制器，您可以在路由声明中使用“点”符号。

1use App\Http\Controllers\PhotoCommentController;
2 
3Route::resource('photos.comments', PhotoCommentController::class);

use App\Http\Controllers\PhotoCommentController;

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

此路由将注册一个嵌套资源，可以通过如下所示的 URI 进行访问：

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

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

嵌套资源作用域

Laravel 的隐式模型绑定功能可以自动对嵌套绑定进行作用域限制，确保解析出的子模型属于父模型。通过在定义嵌套资源时使用 scoped 方法，您可以启用自动作用域限制，并告知 Laravel 应通过哪个字段检索子资源。有关如何实现此操作的更多信息，请参阅关于资源路由作用域的文档。

浅层嵌套

通常，URI 中不必同时包含父 ID 和子 ID，因为子 ID 已经是唯一标识符。在使用自动递增主键等唯一标识符来标识 URI 段中的模型时，您可以选择使用“浅层嵌套”。

1use App\Http\Controllers\CommentController;
2 
3Route::resource('photos.comments', CommentController::class)->shallow();

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

命名资源路由

默认情况下，所有资源控制器动作都有一个路由名称；但是，您可以通过传递一个包含所需路由名称的 names 数组来覆盖这些名称。

1use App\Http\Controllers\PhotoController;
2 
3Route::resource('photos', PhotoController::class)->names([
4    'create' => 'photos.build'
5]);

use App\Http\Controllers\PhotoController;

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

命名资源路由参数

默认情况下，Route::resource 将根据资源名称的“单数”版本为您的资源路由创建路由参数。您可以使用 parameters 方法轻松地为每个资源覆盖此设置。传递给 parameters 方法的数组应该是资源名称和参数名称的关联数组。

1use App\Http\Controllers\AdminUserController;
2 
3Route::resource('users', AdminUserController::class)->parameters([
4    'users' => 'admin_user'
5]);

use App\Http\Controllers\AdminUserController;

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

上面的示例为资源的 show 路由生成了以下 URI：

1/users/{admin_user}

/users/{admin_user}

资源路由作用域

Laravel 的作用域隐式模型绑定功能可以自动对嵌套绑定进行作用域限制，确保解析出的子模型属于父模型。通过在定义嵌套资源时使用 scoped 方法，您可以启用自动作用域限制，并告知 Laravel 应通过哪个字段检索子资源。

1use App\Http\Controllers\PhotoCommentController;
2 
3Route::resource('photos.comments', PhotoCommentController::class)->scoped([
4    'comment' => 'slug',
5]);

use App\Http\Controllers\PhotoCommentController;

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

此路由将注册一个作用域嵌套资源，可以通过如下所示的 URI 进行访问：

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

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

当使用自定义键控隐式绑定作为嵌套路由参数时，Laravel 将自动限制查询范围，以通过父模型检索嵌套模型，并使用约定来猜测父模型上的关系名称。在这种情况下，将假定 Photo 模型具有一个名为 comments（路由参数名称的复数）的关系，该关系可用于检索 Comment 模型。

本地化资源 URI

默认情况下，Route::resource 将使用英语动词和复数规则创建资源 URI。如果您需要本地化 create 和 edit 动作动词，可以使用 Route::resourceVerbs 方法。这可以在应用程序 App\Providers\AppServiceProvider 的 boot 方法开头完成。

 1/**
 2 * Bootstrap any application services.
 3 */
 4public function boot(): void
 5{
 6    Route::resourceVerbs([
 7        'create' => 'crear',
 8        'edit' => 'editar',
 9    ]);
10}

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    Route::resourceVerbs([
        'create' => 'crear',
        'edit' => 'editar',
    ]);
}

Laravel 的复数转换器支持几种不同的语言，您可以根据需要进行配置。一旦自定义了动词和复数语言，资源路由注册（如 Route::resource('publicacion', PublicacionController::class)）将生成以下 URI：

1/publicacion/crear
2
3/publicacion/{publicaciones}/editar

/publicacion/crear

/publicacion/{publicaciones}/editar

补充资源控制器

如果您需要在默认资源路由集之外向资源控制器添加额外的路由，则应在调用 Route::resource 方法之前定义这些路由；否则，由 resource 方法定义的路由可能会无意中优先于您的补充路由。

1use App\Http\Controller\PhotoController;
2 
3Route::get('/photos/popular', [PhotoController::class, 'popular']);
4Route::resource('photos', PhotoController::class);

use App\Http\Controller\PhotoController;

Route::get('/photos/popular', [PhotoController::class, 'popular']);
Route::resource('photos', PhotoController::class);

请记住保持控制器的专注。如果您发现自己经常需要超出典型资源动作集的额外方法，请考虑将控制器拆分为两个更小的控制器。

单例资源控制器

有时，您的应用程序会有可能只有一个实例的资源。例如，用户的“个人资料”可以被编辑或更新，但用户不能拥有多个“个人资料”。同样，一张图片可能只有一个“缩略图”。这些资源被称为“单例资源”，意味着该资源只能存在一个且仅一个实例。在这种情况下，您可以注册一个“单例”资源控制器。

1use App\Http\Controllers\ProfileController;
2use Illuminate\Support\Facades\Route;
3 
4Route::singleton('profile', ProfileController::class);

use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::singleton('profile', ProfileController::class);

上面的单例资源定义将注册以下路由。如您所见，单例资源不注册“创建”路由，且由于该资源只能存在一个实例，注册的路由不接受标识符。

动词	URI	动作	路由名称
GET	`/profile`	show	profile.show
GET	`/profile/edit`	edit	profile.edit
PUT/PATCH	`/profile`	update	profile.update

单例资源也可以嵌套在标准资源中。

1Route::singleton('photos.thumbnail', ThumbnailController::class);

Route::singleton('photos.thumbnail', ThumbnailController::class);

在此示例中，photos 资源将接收所有标准资源路由；但是，thumbnail 资源将是一个单例资源，具有以下路由：

动词	URI	动作	路由名称
GET	`/photos/{photo}/thumbnail`	show	photos.thumbnail.show
GET	`/photos/{photo}/thumbnail/edit`	edit	photos.thumbnail.edit
PUT/PATCH	`/photos/{photo}/thumbnail`	update	photos.thumbnail.update

可创建的单例资源

有时，您可能需要为单例资源定义创建和存储路由。要实现这一点，您可以在注册单例资源路由时调用 creatable 方法。

1Route::singleton('photos.thumbnail', ThumbnailController::class)->creatable();

Route::singleton('photos.thumbnail', ThumbnailController::class)->creatable();

在此示例中，将注册以下路由。如您所见，可创建的单例资源也会注册 DELETE 路由。

动词	URI	动作	路由名称
GET	`/photos/{photo}/thumbnail/create`	create	photos.thumbnail.create
POST	`/photos/{photo}/thumbnail`	store	photos.thumbnail.store
GET	`/photos/{photo}/thumbnail`	show	photos.thumbnail.show
GET	`/photos/{photo}/thumbnail/edit`	edit	photos.thumbnail.edit
PUT/PATCH	`/photos/{photo}/thumbnail`	update	photos.thumbnail.update
DELETE	`/photos/{photo}/thumbnail`	destroy	photos.thumbnail.destroy

如果您希望 Laravel 为单例资源注册 DELETE 路由，但不希望注册创建或存储路由，可以使用 destroyable 方法。

1Route::singleton(...)->destroyable();

Route::singleton(...)->destroyable();

API 单例资源

apiSingleton 方法可用于注册将通过 API 操作的单例资源，从而使 create 和 edit 路由不再必要。

1Route::apiSingleton('profile', ProfileController::class);

Route::apiSingleton('profile', ProfileController::class);

当然，API 单例资源也可以是 creatable 的，这将为资源注册 store 和 destroy 路由。

1Route::apiSingleton('photos.thumbnail', ProfileController::class)->creatable();

Route::apiSingleton('photos.thumbnail', ProfileController::class)->creatable();

中间件与资源控制器

Laravel 允许您使用 middleware、middlewareFor 和 withoutMiddlewareFor 方法将中间件分配给资源路由的全部或特定方法。这些方法提供了对应用于每个资源动作的中间件的细粒度控制。

将中间件应用于所有方法

您可以使用 middleware 方法将中间件分配给资源或单例资源路由生成的所有路由。

1Route::resource('users', UserController::class)
2    ->middleware(['auth', 'verified']);
3 
4Route::singleton('profile', ProfileController::class)
5    ->middleware('auth');

Route::resource('users', UserController::class)
    ->middleware(['auth', 'verified']);

Route::singleton('profile', ProfileController::class)
    ->middleware('auth');

将中间件应用于特定方法

您可以使用 middlewareFor 方法将中间件分配给给定资源控制器的一个或多个特定方法。

 1Route::resource('users', UserController::class)
 2    ->middlewareFor('show', 'auth');
 3 
 4Route::apiResource('users', UserController::class)
 5    ->middlewareFor(['show', 'update'], 'auth');
 6 
 7Route::resource('users', UserController::class)
 8    ->middlewareFor('show', 'auth')
 9    ->middlewareFor('update', 'auth');
10 
11Route::apiResource('users', UserController::class)
12    ->middlewareFor(['show', 'update'], ['auth', 'verified']);

Route::resource('users', UserController::class)
    ->middlewareFor('show', 'auth');

Route::apiResource('users', UserController::class)
    ->middlewareFor(['show', 'update'], 'auth');

Route::resource('users', UserController::class)
    ->middlewareFor('show', 'auth')
    ->middlewareFor('update', 'auth');

Route::apiResource('users', UserController::class)
    ->middlewareFor(['show', 'update'], ['auth', 'verified']);

middlewareFor 方法也可以与单例和 API 单例资源控制器结合使用。

1Route::singleton('profile', ProfileController::class)
2    ->middlewareFor('show', 'auth');
3 
4Route::apiSingleton('profile', ProfileController::class)
5    ->middlewareFor(['show', 'update'], 'auth');

Route::singleton('profile', ProfileController::class)
    ->middlewareFor('show', 'auth');

Route::apiSingleton('profile', ProfileController::class)
    ->middlewareFor(['show', 'update'], 'auth');

从特定方法中排除中间件

您可以使用 withoutMiddlewareFor 方法从资源控制器的特定方法中排除中间件。

1Route::middleware(['auth', 'verified', 'subscribed'])->group(function () {
2    Route::resource('users', UserController::class)
3        ->withoutMiddlewareFor('index', ['auth', 'verified'])
4        ->withoutMiddlewareFor(['create', 'store'], 'verified')
5        ->withoutMiddlewareFor('destroy', 'subscribed');
6});

Route::middleware(['auth', 'verified', 'subscribed'])->group(function () {
    Route::resource('users', UserController::class)
        ->withoutMiddlewareFor('index', ['auth', 'verified'])
        ->withoutMiddlewareFor(['create', 'store'], 'verified')
        ->withoutMiddlewareFor('destroy', 'subscribed');
});

依赖注入与控制器

构造函数注入

Laravel 服务容器用于解析所有 Laravel 控制器。因此，您可以在构造函数中对控制器所需的任何依赖项进行类型提示。声明的依赖项将自动被解析并注入到控制器实例中。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Repositories\UserRepository;
 6 
 7class UserController extends Controller
 8{
 9    /**
10     * Create a new controller instance.
11     */
12    public function __construct(
13        protected UserRepository $users,
14    ) {}
15}

<?php

namespace App\Http\Controllers;

use App\Repositories\UserRepository;

class UserController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected UserRepository $users,
    ) {}
}

方法注入

除了构造函数注入之外，您还可以在控制器的方法上对依赖项进行类型提示。方法注入的一个常见用例是将 Illuminate\Http\Request 实例注入到控制器方法中。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Http\RedirectResponse;
 6use Illuminate\Http\Request;
 7 
 8class UserController extends Controller
 9{
10    /**
11     * Store a new user.
12     */
13    public function store(Request $request): RedirectResponse
14    {
15        $name = $request->name;
16 
17        // Store the user...
18 
19        return redirect('/users');
20    }
21}

<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Store a new user.
     */
    public function store(Request $request): RedirectResponse
    {
        $name = $request->name;

        // Store the user...

        return redirect('/users');
    }
}

如果您的控制器方法还需要来自路由参数的输入，请将路由参数列在其他依赖项之后。例如，如果您的路由定义如下：

1use App\Http\Controllers\UserController;
2 
3Route::put('/user/{id}', [UserController::class, 'update']);

use App\Http\Controllers\UserController;

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

您仍然可以对 Illuminate\Http\Request 进行类型提示，并通过按如下方式定义控制器方法来访问您的 id 参数：

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Http\RedirectResponse;
 6use Illuminate\Http\Request;
 7 
 8class UserController extends Controller
 9{
10    /**
11     * Update the given user.
12     */
13    public function update(Request $request, string $id): RedirectResponse
14    {
15        // Update the user...
16 
17        return redirect('/users');
18    }
19}

<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Update the given user.
     */
    public function update(Request $request, string $id): RedirectResponse
    {
        // Update the user...

        return redirect('/users');
    }
}

控制器

简介

编写控制器

基础控制器

单动作控制器

控制器中间件

中间件属性

授权属性

资源控制器

资源控制器处理的动作

自定义缺失模型的行为

软删除模型

指定资源模型

生成表单请求

部分资源路由

API 资源路由

嵌套资源

嵌套资源作用域

浅层嵌套

命名资源路由

命名资源路由参数

资源路由作用域

本地化资源 URI

补充资源控制器

单例资源控制器

可创建的单例资源

API 单例资源

中间件与资源控制器

将中间件应用于所有方法

将中间件应用于特定方法

从特定方法中排除中间件

依赖注入与控制器

构造函数注入

方法注入

在此页面上

产品

Packages

资源

合作伙伴