Routage, contrôleurs et vues avec Blade dans Laravel

Bienvenue dans cette leçon dédiée aux piliers fondamentaux de toute application Laravel : le routage, les contrôleurs et les vues avec Blade. Ces composants sont au cœur de l'architecture MVC (Modèle-Vue-Contrôleur) de Laravel et sont essentiels pour comprendre comment une requête utilisateur est traitée, comment les données sont gérées et comment le contenu est finalement présenté à l'utilisateur.

En tant que développeur backend expérimenté, maîtriser ces concepts vous permettra de construire des applications robustes, maintenables et évolutives. Nous allons explorer en profondeur chacun de ces éléments, leurs interactions et les meilleures pratiques pour les utiliser efficacement.

1. Introduction à l'Architecture MVC et au Rôle de Chaque Composant

Laravel, comme de nombreux frameworks modernes, suit le modèle architectural MVC (Modèle-Vue-Contrôleur). Ce paradigme de conception vise à séparer les responsabilités de votre application en trois composants interconnectés :

Modèle (Model) : Représente la logique métier et les données. C'est l'interface avec votre base de données. Les modèles sont chargés de récupérer, stocker, mettre à jour et supprimer des informations. (Hors sujet de cette leçon, mais essentiel à comprendre pour le contexte).
Vue (View) : Gère la présentation des données à l'utilisateur. C'est la couche d'interface utilisateur, responsable de l'affichage du HTML, CSS, JavaScript, etc.
Contrôleur (Controller) : Agit comme un intermédiaire entre le modèle et la vue. Il reçoit les requêtes de l'utilisateur, interagit avec le modèle pour récupérer ou manipuler des données, puis passe ces données à la vue appropriée pour l'affichage.

Dans ce contexte, le Routage est la première étape du processus : il dirige la requête entrante vers le contrôleur ou la logique métier appropriée.

2. Le Routage dans Laravel

Le routage est le mécanisme qui permet à votre application Laravel de comprendre quelle portion de code exécuter en réponse à une requête HTTP spécifique (par exemple, accéder à une URL donnée).

2.1. Définition des Routes

Laravel fournit un fichier routes/web.php pour les routes web (sessions, CSRF, etc.) et routes/api.php pour les API sans état. Les routes sont définies en utilisant la façade Route.

// Fichier: routes/web.php

use Illuminate\Support\Facades\Route;

// Route simple qui retourne une chaîne de caractères
Route::get('/bienvenue', function () {
    return 'Bienvenue sur notre application Laravel !';
});

// Route qui retourne une vue directement (sans contrôleur)
Route::get('/a-propos', function () {
    return view('about'); // Cherche resources/views/about.blade.php
});

2.2. Verbes HTTP

Les routes peuvent être définies pour répondre à différents verbes HTTP :

Route::get('/url', ...) : Pour récupérer des ressources.
Route::post('/url', ...) : Pour soumettre des données (ex: formulaires).
Route::put('/url', ...) : Pour mettre à jour des ressources existantes (remplace la ressource complète).
Route::patch('/url', ...) : Pour mettre à jour partiellement des ressources existantes.
Route::delete('/url', ...) : Pour supprimer des ressources.
Route::match(['get', 'post'], '/url', ...) : Pour faire correspondre plusieurs verbes.
Route::any('/url', ...) : Pour faire correspondre tous les verbes HTTP.

2.3. Paramètres de Route

Vous pouvez définir des paramètres dans vos routes pour capturer des segments de l'URL.

Paramètres obligatoires :

Route::get('/users/{id}', function ($id) {
    return 'Affichage de l\'utilisateur ID: ' . $id;
});

Paramètres optionnels : Ajoutez un ? après le nom du paramètre et donnez une valeur par défaut dans la fonction de rappel.
```
Route::get('/posts/{slug?}', function ($slug = 'tous') {
    return 'Affichage du post avec le slug: ' . $slug;
});
```

Contraintes de paramètres (Expressions régulières) : Utilisez la méthode where() pour ajouter des contraintes.

Route::get('/products/{id}/{name}', function ($id, $name) {
    return "Produit ID: $id, Nom: $name";
})->where(['id' => '[0-9]+', 'name' => '[a-zA-Z]+']);

2.4. Routes Nommées

Nommer vos routes est une excellente pratique. Cela vous permet de générer des URL en utilisant le nom de la route, ce qui rend votre application plus flexible si les URL changent à l'avenir.

// Fichier: routes/web.php

Route::get('/dashboard/profil', function () {
    // ...
})->name('profile');

// Plus tard dans votre code ou vos vues Blade:
// Générer l'URL: route('profile') -> http://localhost/dashboard/profil
// Redirection: redirect()->route('profile');

2.5. Groupes de Routes

Les groupes de routes vous permettent d'appliquer des attributs communs (middleware, préfixe, namespace, etc.) à un ensemble de routes.

// Fichier: routes/web.php

Route::middleware('auth')->group(function () { // Applique le middleware 'auth' à toutes les routes du groupe
    Route::get('/admin/dashboard', function () {
        return 'Tableau de bord admin';
    });

    Route::get('/admin/users', function () {
        return 'Gestion des utilisateurs admin';
    });
});

Route::prefix('blog')->group(function () { // Ajoute '/blog' comme préfixe aux URLs
    Route::get('/', function () {
        return 'Liste des articles de blog';
    });
    Route::get('/{slug}', function ($slug) {
        return "Article: $slug";
    });
});

2.6. Routes de Redirection et de Vue

Laravel offre des raccourcis pour des cas d'utilisation courants :

Route::redirect('/old-url', '/new-url', 301); : Redirige une URL vers une autre avec un code de statut HTTP (301 pour permanent, 302 pour temporaire).
Route::view('/welcome', 'welcome', ['name' => 'Jean']); : Retourne directement une vue avec des données, sans passer par une fonction de rappel ou un contrôleur.

3. Les Contrôleurs dans Laravel

Les contrôleurs servent de couche intermédiaire entre le routage et la logique métier/présentation. Leur rôle principal est de recevoir les requêtes, d'interagir avec les modèles (s'il y a lieu), et de retourner une réponse (souvent en rendant une vue).

3.1. Pourquoi Utiliser des Contrôleurs ?

Séparation des préoccupations (SoC) : Ils séparent la logique de traitement des requêtes de la définition des routes et de la logique de présentation.
Organisation : Regroupez la logique métier liée à une ressource spécifique (ex: UserController pour tout ce qui concerne les utilisateurs).
Réutilisabilité : La logique peut être réutilisée plus facilement.
Testabilité : Les contrôleurs sont plus faciles à tester unitairement que des fonctions de rappel anonymes dans les routes.

3.2. Créer un Contrôleur

Utilisez l'artisan command-line interface pour créer un contrôleur :

php artisan make:controller UserController

Ceci créera un fichier app/Http/Controllers/UserController.php :

// Fichier: app/Http/Controllers/UserController.php

namespace App\Http\Controllers;

use App\Models\User; // Exemple, si vous avez un modèle User
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Affiche une liste des utilisateurs.
     *
     * @return \Illuminate\View\View
     */
    public function index()
    {
        $users = User::all(); // Récupère tous les utilisateurs via le modèle
        return view('users.index', compact('users')); // Passe les utilisateurs à la vue
    }

    /**
     * Affiche le formulaire de création d'un nouvel utilisateur.
     *
     * @return \Illuminate\View\View
     */
    public function create()
    {
        return view('users.create');
    }

    /**
     * Stocke un nouvel utilisateur dans la base de données.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function store(Request $request)
    {
        // Valider les données, stocker en base de données
        $validatedData = $request->validate([
            'name' => 'required|max:255',
            'email' => 'required|email|unique:users',
            'password' => 'required|min:8',
        ]);

        User::create($validatedData);

        return redirect()->route('users.index')->with('success', 'Utilisateur créé avec succès !');
    }

    /**
     * Affiche un utilisateur spécifique.
     *
     * @param  int  $id
     * @return \Illuminate\View\View
     */
    public function show($id)
    {
        $user = User::findOrFail($id); // Trouve l'utilisateur ou génère une erreur 404
        return view('users.show', compact('user'));
    }

    // ... et d'autres méthodes comme edit, update, destroy
}

3.3. Lier les Routes aux Contrôleurs

Au lieu d'utiliser des fonctions de rappel, vous pointez la route vers une méthode du contrôleur :

// Fichier: routes/web.php

use App\Http\Controllers\UserController;

// Route qui pointe vers la méthode 'index' du UserController
Route::get('/users', [UserController::class, 'index'])->name('users.index');

// Route avec paramètre qui pointe vers la méthode 'show'
Route::get('/users/{id}', [UserController::class, 'show'])->name('users.show');

// Route POST pour la création (pointe vers la méthode 'store')
Route::post('/users', [UserController::class, 'store'])->name('users.store');

3.4. Contrôleurs de Ressources (Resource Controllers)

Laravel offre une fonctionnalité puissante pour les opérations CRUD (Create, Read, Update, Delete) : les contrôleurs de ressources. Un seul contrôleur peut gérer toutes les actions pour une ressource donnée.

Pour créer un contrôleur de ressource :

php artisan make:controller PostController --resource

Ceci générera un PostController avec des méthodes vides pour index, create, store, show, edit, update, destroy.

Pour lier ces routes automatiquement :

// Fichier: routes/web.php

use App\Http\Controllers\PostController;

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

Cette seule ligne génère automatiquement les routes suivantes (et les noms de route associés, ex: posts.index, posts.show):

| Verbe HTTP | URI | Nom de la Route | Action du Contrôleur | | :--------- | :------------- | :-------------- | :------------------- | | GET | /posts | posts.index | index | | GET | /posts/create| posts.create | create | | POST | /posts | posts.store | store | | GET | /posts/{post}| posts.show | show | | GET | /posts/{post}/edit| posts.edit | edit | | PUT/PATCH | /posts/{post}| posts.update | update | | DELETE | /posts/{post}| posts.destroy | destroy |

Vous pouvez restreindre les méthodes générées : Route::resource('photos', PhotoController::class)->only(['index', 'show']); ou ->except(['create', 'store', 'update', 'destroy']);.

4. Les Vues avec Blade

Les vues sont la couche de présentation de votre application. Elles contiennent le HTML et le CSS de votre interface utilisateur, et elles affichent les données que le contrôleur leur a passées. Laravel utilise Blade, un moteur de template puissant et simple d'utilisation.

4.1. Pourquoi Blade ?

Blade ne vous limite pas à utiliser du PHP pur dans vos vues, mais il fournit des raccourcis pratiques pour des tâches courantes comme l'affichage de données, les boucles, les conditions et l'héritage de template. Il compile vos vues Blade en code PHP brut et les met en cache, ce qui signifie qu'il n'ajoute pratiquement aucune surcharge à votre application.

4.2. Base de la Syntaxe Blade

Les fichiers de vue Blade se terminent par .blade.php (ex: resources/views/welcome.blade.php).

Affichage de données : Utilisez les doubles accolades {{ }} pour afficher le contenu d'une variable. Blade échappe automatiquement les sorties pour éviter les attaques XSS.
```

<h1>Bonjour, {{ $name }} !</h1>
```
Si name contient des balises HTML, elles seront affichées en tant que texte.
Affichage de données non échappées : Utilisez les triples accolades {!! !!} si vous êtes certain que le contenu est sûr et que vous voulez afficher du HTML brut (ex: contenu d'un éditeur WYSIWYG).
```

<article>
    {!! $articleContent !!}
</article>
```
Attention : N'utilisez cette syntaxe qu'avec des données dont vous maîtrisez la source et le contenu pour éviter les vulnérabilités XSS.

4.3. Structures de Contrôle Blade

Blade fournit des directives pratiques pour les conditions, les boucles, etc.

Conditions (@if, @else, @elseif, @endif) :

@if (count($users) === 1)
    Il y a un seul utilisateur.
@elseif (count($users) > 1)
    Il y a plusieurs utilisateurs.
@else
    Aucun utilisateur.
@endif

@unless (Auth::check()) {{-- Equivalent à @if (!Auth::check()) --}}
    Vous n'êtes pas connecté.
@endunless

Boucles (@foreach, @for, @while) :

<ul>
    @foreach ($users as $user)
        <li>{{ $user->name }}</li>
    @endforeach
</ul>

@for ($i = 0; $i < 10; $i++)
    Le numéro actuel est {{ $i }}
@endfor

4.4. Héritage de Template (`@extends`, `@section`, `@yield`)

L'héritage de template est l'une des fonctionnalités les plus puissantes de Blade. Elle vous permet de définir une mise en page principale et de laisser les vues enfants "remplir" ou "étendre" des sections spécifiques de cette mise en page.

Créer une mise en page principale (Layout) :

<!-- resources/views/layouts/app.blade.php -->

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@yield('title', 'Mon Application Laravel')</title> {{-- 'Mon Application Laravel' est la valeur par défaut --}}
    <link rel="stylesheet" href="/css/app.css">
</head>
<body>
    <header>
        <nav>
            <a href="/">Accueil</a>
            <a href="/a-propos">À Propos</a>
        </nav>
    </header>

    <main>
        @yield('content') {{-- Ici le contenu principal des pages sera injecté --}}
    </main>

    <footer>
        <p>&copy; {{ date('Y') }} Mon Application</p>
    </footer>

    <script src="/js/app.js"></script>
</body>
</html>

Étendre la mise en page dans une vue enfant :

<!-- resources/views/welcome.blade.php -->

@extends('layouts.app') {{-- Indique que cette vue étend layouts/app.blade.php --}}

@section('title', 'Page d\'Accueil') {{-- Rempli la section 'title' --}}

@section('content') {{-- Rempli la section 'content' --}}
    <h1>Bienvenue sur ma page d'accueil !</h1>
    <p>Ceci est le contenu principal de la page.</p>
@endsection

Lorsque welcome.blade.php est rendu, Blade injecte le contenu de @section('title') dans le @yield('title') du layout, et le contenu de @section('content') dans le @yield('content').

4.5. Inclusion de Sous-Vues (`@include`)

Vous pouvez inclure d'autres vues Blade dans une vue. C'est utile pour des composants réutilisables comme des alertes ou des barres latérales.

<!-- resources/views/parts/alert.blade.php -->
<div class="alert alert-{{ $type ?? 'info' }}">
    {{ $message ?? 'Pas de message.' }}
</div>

<!-- resources/views/dashboard.blade.php -->
@include('parts.alert', ['type' => 'success', 'message' => 'Opération réussie !'])
@include('parts.alert', ['message' => 'Attention, quelque chose s\'est passé.'])

4.6. Passer des Données aux Vues

Il existe plusieurs façons de passer des données d'un contrôleur (ou d'une route) à une vue :

compact() (recommandé) :

// Dans votre contrôleur
$name = 'Alice';
$age = 30;
return view('profile', compact('name', 'age')); // Crée ['name' => $name, 'age' => $age]

Tableau associatif :

// Dans votre contrôleur
$user = ['name' => 'Bob', 'email' => 'bob@example.com'];
return view('user_details', ['user' => $user]);

with() :

// Dans votre contrôleur
$products = ['pomme', 'poire'];
return view('products')->with('products', $products);

Dans votre vue Blade, les données seront accessibles comme des variables PHP standards (ex: $name, $age, $user, $products).

5. Le Flux MVC Complet dans Laravel

Pour récapituler, voici comment une requête typique transite à travers les composants que nous avons étudiés :

Requête HTTP : Un utilisateur tape une URL dans son navigateur (ex: https://example.com/users/1) ou soumet un formulaire.
Routage : Laravel reçoit la requête. Le routeur examine l'URL et le verbe HTTP, puis trouve la route correspondante définie dans routes/web.php (ou api.php).
Contrôleur : La route dirige la requête vers une méthode spécifique d'un contrôleur (ex: UserController@show). Le contrôleur :
- Récupère les données nécessaires (ex: utilisateur ID 1) en interagissant avec le Modèle (ex: User::find(1)).
- Traite la logique métier.
- Prépare les données à afficher.
Vue avec Blade : Le contrôleur retourne une vue (ex: return view('users.show', compact('user'))). Blade prend le fichier de vue (ex: resources/views/users/show.blade.php), y injecte les données fournies par le contrôleur, et le compile en HTML brut.
Réponse HTTP : Le HTML généré est renvoyé au navigateur de l'utilisateur.

Ce cycle assure une séparation claire des responsabilités, rendant les applications Laravel faciles à développer, à maintenir et à faire évoluer.

Conclusion

Nous avons parcouru les concepts fondamentaux du routage, des contrôleurs et des vues avec Blade dans Laravel. Vous devriez maintenant avoir une compréhension solide de :

L'importance du routage pour diriger les requêtes entrantes.
Le rôle central des contrôleurs dans la gestion de la logique de l'application et la coordination entre les modèles et les vues.
La puissance du moteur de templating Blade pour créer des interfaces utilisateur dynamiques et maintenables grâce à l'héritage et aux structures de contrôle.

La maîtrise de ces trois piliers est indispensable pour construire des applications Laravel de qualité. En appliquant les bonnes pratiques (routes nommées, contrôleurs de ressources, héritage de template), vous développerez des applications plus claires, plus modulaires et plus performantes. Continuez à expérimenter et à construire pour solidifier ces connaissances !