O que são controladores no Laravel?

Question

Accepted Answer

**Controladores** agrupam a lógica de tratamento de requisição relacionada em classes. Em vez de colocar toda a lógica em closures de rota, os controladores organizam as ações de uma aplicação (por exemplo, todas as operações relacionadas ao usuário) em métodos — mantendo as rotas limpas e o código organizado.

## Um controlador básico

```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
    }
}
```

Gere um com Artisan: `php artisan make:controller UserController`. Cada método trata uma ação e as rotas apontam para eles.

## Controladores de recurso (CRUD RESTful)

```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()
```

Um **controlador de recurso** possui os métodos CRUD padrão, acoplados com `Route::resource` para roteamento RESTful convencional — boilerplate mínimo para recursos CRUD típicos.

## Injeção de dependência em controladores

```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
    }
}
```

O contêiner de serviços Laravel **injeta automaticamente** dependências com type-hint em construtores e métodos de controladores (incluindo a `Request`) — código limpo e testável.

## Mantenha os controladores enxutos

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

## Por que isso importa

Os controladores são um bloco de construção central do Laravel — eles organizam a lógica de tratamento de requisição em classes coesivas, o que é essencial para qualquer aplicação além de rotas triviais.

Compreender como criar controladores, mapear rotas para seus métodos e, especialmente, usar **controladores de recurso** com `Route::resource` (para CRUD RESTful convencional com boilerplate mínimo) é conhecimento cotidiano para construir aplicativos Laravel.

Um recurso-chave do Laravel é a **injeção automática de dependência** em controladores através do contêiner de serviços — dependências com type-hint (serviços, a requisição, mailers) são resolvidas e injetadas automaticamente, permitindo código limpo, testável e fracamente acoplado.

Igualmente importante é a melhor prática de manter os controladores **enxutos** — tratando apenas preocupações HTTP (validação, chamada de serviços, retorno de respostas) e delegando a lógica comercial para serviços/modelos, o que mantém o código mantível e testável.

Os controladores, juntamente com roteamento e modelos, formam a base do tratamento de requisição do Laravel, tornando-os fundamentais para construir aplicativos Laravel bem organizados e profissionais.