A resource controller organizes logic for handling HTTP actions around resources, providing a consistent way to manage CRUD operations. It includes predefined methods like index(), create(), store(), show(), edit(), update(), and destroy(), each mapped to specific HTTP verbs and URLs. In Laravel, it’s created using php artisan make:controller PostController --resource, and routes are defined with Route::resource('posts', 'PostController'), automating RESTful route patterns. Tips include following naming conventions, implementing only needed methods, applying middleware, grouping routes, and using API-specific controllers when appropriate.

Resource controllers are a feature in many web frameworks—like Laravel—that help organize the logic for handling common HTTP actions (like create, read, update, and delete) around resources. Instead of manually defining each route and controller method separately, resource controllers let you define them all at once in a consistent way.

What Exactly Is a Resource Controller?

At its core, a resource controller is just a regular controller that follows a set of naming conventions tied to standard CRUD operations. When you generate or define one, it typically includes methods like:

• index() – show a list of items
• create() – display a form to create a new item
• store() – handle saving a new item
• show() – display a single item
• edit() – display a form to edit an item
• update() – handle updating an existing item
• destroy() – delete an item

Each of these methods corresponds with a specific HTTP verb and URL pattern, which makes routing easier and more predictable.

How to Create a Resource Controller

Creating a resource controller depends on your framework, but in most cases—especially Laravel—it’s straightforward.

For example, in Laravel, you can use Artisan:

php artisan make:controller PostController --resource

This command creates a PostController with all the standard CRUD methods already defined as empty functions. You then fill in the actual logic based on your application's needs.

If you're not using a framework that supports this out of the box, you can still manually create a controller and add those seven standard methods yourself. Just follow a naming convention and map your routes accordingly.

Setting Up Routes for the Resource Controller

Once you have the controller, you need to hook it up to your app’s routing system.

In Laravel, again, it's simple:

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

This single line sets up all the necessary routes pointing to the correct controller methods, following standard RESTful patterns like:

• GET /posts → index()
• GET /posts/create → create()
• POST /posts → store()
• GET /posts/{id} → show()
• GET /posts/{id}/edit → edit()
• PUT/PATCH /posts/{id} → update()
• DELETE /posts/{id} → destroy()

Other frameworks or custom setups will require similar mappings, usually handled in a routes file or configuration.

Tips for Using Resource Controllers Effectively

Here are a few practical tips when working with resource controllers:

• Stick to the naming conventions unless you have a strong reason not to. It helps keep things predictable and maintainable.
• Only implement the methods you need. If your app only shows and stores data, no need to include edit() or destroy().
• Use middleware wisely. Apply access control or authentication inside the controller constructor or route definitions.
• Group related routes together. This keeps your route files clean and organized.

You can also create API resource controllers, which skip view-related methods (create, edit) if you’re building a backend-only service.

That’s basically how resource controllers work and how to create them. It’s a small setup that pays off in consistency and readability over time.

The above is the detailed content of What are resource controllers, and how do I create them?. For more information, please follow other related articles on the PHP Chinese website!