Qu'est-ce que les contrôleurs dans 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.

## Un contrôleur basique

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

Générez-en un avec Artisan : `php artisan make:controller UserController`. Chaque méthode gère une action, et les routes pointent vers elles.

## Contrôleurs de ressource (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()
```

Un **resource controller** a les méthodes CRUD standard, associées à `Route::resource` pour un routage RESTful conventionnel — boilerplate minimal pour les ressources CRUD typiques.

## Injection de dépendances dans les contrôleurs

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

Le service container de Laravel **injecte automatiquement** les dépendances type-hintées dans les constructeurs et méthodes des contrôleurs (y compris le `Request`) — code propre et testable.

## Garder les contrôleurs minces

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

## Pourquoi c'est important

Les contrôleurs sont un élément fondamental de Laravel — ils organisent la logique de traitement des requêtes en classes cohésives, ce qui est essentiel pour toute application au-delà des routes triviales.

Comprendre comment créer des contrôleurs, mapper les routes vers leurs méthodes, et surtout utiliser les **resource controllers** avec `Route::resource` (pour un CRUD RESTful conventionnel avec boilerplate minimal) est une connaissance quotidienne pour construire des applications Laravel.

Une fonctionnalité clé de Laravel est l'**injection automatique de dépendances** dans les contrôleurs via le service container — les dépendances type-hintées (services, la requête, mailers) sont résolues et injectées automatiquement, permettant un code propre, testable et faiblement couplé.

Tout aussi important est la meilleure pratique de garder les contrôleurs **minces** — en gérant uniquement les préoccupations HTTP (validation, appel de services, renvoi de réponses) et en déléguant la logique métier aux services/modèles, ce qui maintient le code maintenable et testable.

Les contrôleurs, avec le routage et les modèles, forment l'épine dorsale de la gestion des requêtes de Laravel, ce qui les rend fondamentaux pour construire des applications Laravel bien organisées et professionnelles.