Introduction
Instead of defining all of your request handling logic as closures in
your route files, you may wish to organize this behavior using
"controller" classes. Controllers can group related request handling
logic into a single class. For example, a UserController
class might handle all incoming requests related to users, including
showing, creating, updating, and deleting users. By default, controllers
are stored in the app/Http/Controllers
directory.
Writing Controllers
Basic Controllers
Let's take a look at an example of a basic controller. Note that the
controller extends the base controller class included with Laravel:
App\Http\Controllers\Controller
:
<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Models\User;
class UserController extends Controller
{
/**
* Show the profile for a given user.
*
* @param int $id
* @return \Illuminate\View\View
*/
public function show($id)
{
return view('user.profile', [
'user' => User::findOrFail($id)
]);
}
}
You can define a route to this controller method like so:
use App\Http\Controllers\UserController;
Route::get('/user/{id}', [UserController::class, 'show']);
When an incoming request matches the specified route URI, the
show
method on the
App\Http\Controllers\UserController
class will be invoked
and the route parameters will be passed to the method.
Tip!! Controllers are not required to extend a base class. However, you will not have access to convenient features such as the
middleware
andauthorize
methods.
Single Action Controllers
If a controller action is particularly complex, you might find it
convenient to dedicate an entire controller class to that single action.
To accomplish this, you may define a single __invoke
method
within the controller:
<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Models\User;
class ProvisionServer extends Controller
{
/**
* Provision a new web server.
*
* @return \Illuminate\Http\Response
*/
public function __invoke()
{
// ...
}
}
When registering routes for single action controllers, you do not need to specify a controller method. Instead, you may simply pass the name of the controller to the router:
use App\Http\Controllers\ProvisionServer;
Route::post('/server', ProvisionServer::class);
You may generate an invokable controller by using the
--invokable
option of the make:controller
Artisan command:
php artisan make:controller ProvisionServer --invokable
Tip!! Controller stubs may be customized using stub publishing.
Controller Middleware
Middleware may be assigned to the controller's routes in your route files:
Route::get('profile', [UserController::class, 'show'])->middleware('auth');
Or, you may find it convenient to specify middleware within your
controller's constructor. Using the middleware
method
within your controller's constructor, you can assign middleware to the
controller's actions:
class UserController extends Controller
{
/**
* Instantiate a new controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware('auth');
$this->middleware('log')->only('index');
$this->middleware('subscribed')->except('store');
}
}
Controllers also allow you to register middleware using a closure. This provides a convenient way to define an inline middleware for a single controller without defining an entire middleware class:
$this->middleware(function ($request, $next) {
return $next($request);
});
Resource Controllers
If you think of each Eloquent model in your application as a
"resource", it is typical to perform the same sets of actions against
each resource in your application. For example, imagine your application
contains a Photo
model and a Movie
model. It
is likely that users can create, read, update, or delete these
resources.
Because of this common use case, Laravel resource routing assigns the
typical create, read, update, and delete ("CRUD") routes to a controller
with a single line of code. To get started, we can use the
make:controller
Artisan command's --resource
option to quickly create a controller to handle these actions:
php artisan make:controller PhotoController --resource
This command will generate a controller at
app/Http/Controllers/PhotoController.php
. The controller
will contain a method for each of the available resource operations.
Next, you may register a resource route that points to the
controller:
use App\Http\Controllers\PhotoController;
Route::resource('photos', PhotoController::class);
This single route declaration creates multiple routes to handle a
variety of actions on the resource. The generated controller will
already have methods stubbed for each of these actions. Remember, you
can always get a quick overview of your application's routes by running
the route:list
Artisan command.
You may even register many resource controllers at once by passing an
array to the resources
method:
Route::resources([
'photos' => PhotoController::class,
'posts' => PostController::class,
]);
Actions Handled By Resource Controller
Verb | URI | Action | Route 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 |
Customizing Missing Model Behavior
Typically, a 404 HTTP response will be generated if an implicitly
bound resource model is not found. However, you may customize this
behavior by calling the missing
method when defining your
resource route. The missing
method accepts a closure that
will be invoked if an implicitly bound model can not be found for any of
the resource's routes:
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');
});
Specifying The Resource Model
If you are using route
model binding and would like the resource controller's methods to
type-hint a model instance, you may use the --model
option
when generating the controller:
php artisan make:controller PhotoController --model=Photo --resource
Generating Form Requests
You may provide the --requests
option when generating a
resource controller to instruct Artisan to generate form request classes
for the controller's storage and update methods:
php artisan make:controller PhotoController --model=Photo --resource --requests
Partial Resource Routes
When declaring a resource route, you may specify a subset of actions the controller should handle instead of the full set of default actions:
use App\Http\Controllers\PhotoController;
Route::resource('photos', PhotoController::class)->only([
'index', 'show'
]);
Route::resource('photos', PhotoController::class)->except([
'create', 'store', 'update', 'destroy'
]);
API Resource Routes
When declaring resource routes that will be consumed by APIs, you
will commonly want to exclude routes that present HTML templates such as
create
and edit
. For convenience, you may use
the apiResource
method to automatically exclude these two
routes:
use App\Http\Controllers\PhotoController;
Route::apiResource('photos', PhotoController::class);
You may register many API resource controllers at once by passing an
array to the apiResources
method:
use App\Http\Controllers\PhotoController;
use App\Http\Controllers\PostController;
Route::apiResources([
'photos' => PhotoController::class,
'posts' => PostController::class,
]);
To quickly generate an API resource controller that does not include
the create
or edit
methods, use the
--api
switch when executing the
make:controller
command:
php artisan make:controller PhotoController --api
Nested Resources
Sometimes you may need to define routes to a nested resource. For example, a photo resource may have multiple comments that may be attached to the photo. To nest the resource controllers, you may use "dot" notation in your route declaration:
use App\Http\Controllers\PhotoCommentController;
Route::resource('photos.comments', PhotoCommentController::class);
This route will register a nested resource that may be accessed with URIs like the following:
/photos/{photo}/comments/{comment}
Scoping Nested Resources
Laravel's implicit model
binding feature can automatically scope nested bindings such that
the resolved child model is confirmed to belong to the parent model. By
using the scoped
method when defining your nested resource,
you may enable automatic scoping as well as instruct Laravel which field
the child resource should be retrieved by. For more information on how
to accomplish this, please see the documentation on scoping resource routes.
Shallow Nesting
Often, it is not entirely necessary to have both the parent and the child IDs within a URI since the child ID is already a unique identifier. When using unique identifiers such as auto-incrementing primary keys to identify your models in URI segments, you may choose to use "shallow nesting":
use App\Http\Controllers\CommentController;
Route::resource('photos.comments', CommentController::class)->shallow();
This route definition will define the following routes:
Verb | URI | Action | Route Name |
---|---|---|---|
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 |
Naming Resource Routes
By default, all resource controller actions have a route name;
however, you can override these names by passing a names
array with your desired route names:
use App\Http\Controllers\PhotoController;
Route::resource('photos', PhotoController::class)->names([
'create' => 'photos.build'
]);
Naming Resource Route Parameters
By default, Route::resource
will create the route
parameters for your resource routes based on the "singularized" version
of the resource name. You can easily override this on a per resource
basis using the parameters
method. The array passed into
the parameters
method should be an associative array of
resource names and parameter names:
use App\Http\Controllers\AdminUserController;
Route::resource('users', AdminUserController::class)->parameters([
'users' => 'admin_user'
]);
The example above generates the following URI for the resource's
show
route:
/users/{admin_user}
Scoping Resource Routes
Laravel's scoped implicit model
binding feature can automatically scope nested bindings such that
the resolved child model is confirmed to belong to the parent model. By
using the scoped
method when defining your nested resource,
you may enable automatic scoping as well as instruct Laravel which field
the child resource should be retrieved by:
use App\Http\Controllers\PhotoCommentController;
Route::resource('photos.comments', PhotoCommentController::class)->scoped([
'comment' => 'slug',
]);
This route will register a scoped nested resource that may be accessed with URIs like the following:
/photos/{photo}/comments/{comment:slug}
When using a custom keyed implicit binding as a nested route
parameter, Laravel will automatically scope the query to retrieve the
nested model by its parent using conventions to guess the relationship
name on the parent. In this case, it will be assumed that the
Photo
model has a relationship named comments
(the plural of the route parameter name) which can be used to retrieve
the Comment
model.
Localizing Resource URIs
By default, Route::resource
will create resource URIs
using English verbs. If you need to localize the create
and
edit
action verbs, you may use the
Route::resourceVerbs
method. This may be done at the
beginning of the boot
method within your application's
App\Providers\RouteServiceProvider
:
/**
* Define your route model bindings, pattern filters, etc.
*
* @return void
*/
public function boot()
{
Route::resourceVerbs([
'create' => 'crear',
'edit' => 'editar',
]);
// ...
}
Once the verbs have been customized, a resource route registration
such as Route::resource('fotos', PhotoController::class)
will produce the following URIs:
/fotos/crear
/fotos/{foto}/editar
Supplementing Resource Controllers
If you need to add additional routes to a resource controller beyond
the default set of resource routes, you should define those routes
before your call to the Route::resource
method; otherwise,
the routes defined by the resource
method may
unintentionally take precedence over your supplemental routes:
use App\Http\Controller\PhotoController;
Route::get('/photos/popular', [PhotoController::class, 'popular']);
Route::resource('photos', PhotoController::class);
Tip!! Remember to keep your controllers focused. If you find yourself routinely needing methods outside of the typical set of resource actions, consider splitting your controller into two, smaller controllers.
Dependency Injection & Controllers
Constructor Injection
The Laravel service container is used to resolve all Laravel controllers. As a result, you are able to type-hint any dependencies your controller may need in its constructor. The declared dependencies will automatically be resolved and injected into the controller instance:
<?php
namespace App\Http\Controllers;
use App\Repositories\UserRepository;
class UserController extends Controller
{
/**
* The user repository instance.
*/
protected $users;
/**
* Create a new controller instance.
*
* @param \App\Repositories\UserRepository $users
* @return void
*/
public function __construct(UserRepository $users)
{
$this->users = $users;
}
}
Method Injection
In addition to constructor injection, you may also type-hint
dependencies on your controller's methods. A common use-case for method
injection is injecting the Illuminate\Http\Request
instance
into your controller methods:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
/**
* Store a new user.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$name = $request->name;
//
}
}
If your controller method is also expecting input from a route parameter, list your route arguments after your other dependencies. For example, if your route is defined like so:
use App\Http\Controllers\UserController;
Route::put('/user/{id}', [UserController::class, 'update']);
You may still type-hint the Illuminate\Http\Request
and
access your id
parameter by defining your controller method
as follows:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
/**
* Update the given user.
*
* @param \Illuminate\Http\Request $request
* @param string $id
* @return \Illuminate\Http\Response
*/
public function update(Request $request, $id)
{
//
}
}