What are controllers in Laravel?

Question

Accepted Answer

**Controllers** group related request-handling logic into classes. Instead of putting all logic in route closures, controllers organize an application's actions (e.g. all user-related operations) into methods — keeping routes clean and code organized.

## A basic controller

```php
<?php
class UserController extends Controller {
    public function index() {
        return User::all();              // list users
    }
    public function show(User $user) {   // route model binding — auto-fetch by id
        return $user;
    }
    public function store(Request $request) {
        $validated = $request->validate(['name' => 'required', 'email' => 'required|email']);
        return User::create($validated);  // create
    }
}
```

Generate one with Artisan: `php artisan make:controller UserController`. Each method handles one action, and routes point to them.

## Resource controllers (RESTful CRUD)

```php
// generate a controller with all 7 RESTful methods stubbed
// php artisan make:controller PostController --resource

Route::resource('posts', PostController::class);   // maps routes to the methods:
// index() create() store() show() edit() update() destroy()
```

A **resource controller** has the standard CRUD methods, paired with `Route::resource` for conventional RESTful routing — minimal boilerplate for typical CRUD resources.

## Dependency injection in controllers

```php
class OrderController extends Controller {
    // type-hinted dependencies are AUTO-INJECTED by Laravel's service container
    public function __construct(private OrderService $orders) {}

public function store(Request $request, Mailer $mailer) {   // method injection too
        // $request and $mailer are resolved & injected automatically
    }
}
```

Laravel's service container **automatically injects** type-hinted dependencies into controller constructors and methods (including the `Request`) — clean, testable code.

## Keep controllers thin

```text
✓ Controllers should handle HTTP concerns (validate input, call services, return responses)
✗ Business logic belongs in SERVICES/models, not bloated controllers ("thin controllers")
```

## Why it matters

Controllers are a core Laravel building block — they organize request-handling logic into cohesive classes, which is essential for any application beyond trivial routes.

Understanding how to create controllers, map routes to their methods, and especially use **resource controllers** with `Route::resource` (for conventional RESTful CRUD with minimal boilerplate) is everyday knowledge for building Laravel apps.

A key Laravel feature is **automatic dependency injection** into controllers via the service container — type-hinted dependencies (services, the request, mailers) are resolved and injected automatically, enabling clean, testable, loosely-coupled code.

Equally important is the best practice of keeping controllers **thin** — handling only HTTP concerns (validation, calling services, returning responses) and delegating business logic to services/models, which keeps code maintainable and testable.

Controllers, together with routing and models, form the backbone of Laravel's request handling, making them fundamental to building well-organized, professional Laravel applications.