4.2Laravel : routes, Blade, Eloquent (ORM), migrations
L'essentiel en 30 secondes
- Routage + contrôleurs :
Route::get('/produits', [ProduitController::class, 'index'])dirige l'URL vers l'action ; Artisan génère le code. - Blade + Eloquent : templates
{{ }}avec échappement auto (anti-XSS), et base manipulée en objets (Produit::where(...)->get()) avec requêtes préparées auto. - Réflexe de Riad : versionner la base en migrations et comprendre le SQL généré (attention au N+1) au lieu de subir l'ORM.
Mini-cas filé — Riad passe son catalogue sous Laravel
Le catalogue MVC de Riad (4.1) grandit : il le porte sous Laravel à Constantine. Il déclare ses routes vers un ProduitController, affiche avec une vue Blade qui échappe par défaut, lit la base via Eloquent sans écrire de SQL, et décrit la table produits dans une migration versionnée avec Git. Quand un collègue récupère le projet, une commande installe, une autre migre — et la base est identique. Deuxième jalon du fil rouge : productif, structuré et sûr par défaut.
Suite du cas 4.1 — Riad industrialise son MVC avec un framework.
1. Routage, contrôleurs, Artisan
Laravel implémente le MVC avec des outils élégants. Le routage associe URL et actions : Route::get('/produits', [ProduitController::class, 'index']) envoie les GET vers la méthode index — expressif (GET/POST, paramètres, groupes, middlewares). Les contrôleurs traitent les requêtes (reçoivent, appellent les modèles, retournent vue ou réponse). La ligne de commande Artisan génère contrôleurs et modèles, lance les migrations : Riad scaffolde en secondes au lieu de copier-coller.
2. Blade : les vues sûres
Blade est le moteur de templates : {{ $variable }} pour afficher, @foreach et @if pour la logique d'affichage, layouts réutilisables par héritage. Son atout majeur : l'échappement automatique — les données sont échappées par défaut, ce qui protège du XSS sans y penser. Riad remplace son mélange PHP/HTML brut par des templates lisibles et sûrs.
3. Eloquent et migrations : les données
Eloquent est l'ORM : les tables deviennent des classes, les lignes des objets — Produit::all(), Produit::find($id), Produit::where('prix', '>', 100)->get(), $produit->save() — avec requêtes préparées automatiques (anti-injection) et relations élégantes. Les migrations versionnent la structure de la base en code PHP : reproductible, traçable, essentielle en équipe et au déploiement. Riad retient deux vigilances : comprendre le SQL généré et éviter le N+1 par eager loading (with()). Laravel ajoute auth, validation, CSRF auto, sessions sécurisées : un excellent investissement, framework le plus demandé.
🔎 Exemple concret — 🔎 Exemple concret — Catalogue produits sous Laravel
Les quatre gestes de Riad, avec les API réelles :
Route::get('/produits', [ProduitController::class, 'index']);
$produits = Produit::where('prix', '>', 100)->get(); // all(), find($id)
return view('produits.index', ['produits' => $produits]);
Blade : {{ $p->nom }} + @foreach ($produits as $p) ... @endforeachLecture : route, requête objet, vue, template — chacun à sa place.
Leçon : le framework applique le MVC et la sécurité par défaut.
Vocabulaire de la section
- Laravel
- Le framework PHP le plus populaire (élégant, productif, vaste écosystème) ; implémente le MVC avec les bonnes pratiques. La référence du PHP moderne.
Exemple simple : Riad y porte son catalogue pour aller vite sans sacrifier la structure.
Ce que ce n'est pas : un empilement de scripts sans routage ni ORM.
Réflexe : penser routes, contrôleurs, Blade, Eloquent, migrations.
- Routage / contrôleurs / Artisan
- Routage : URL → actions (Route::get). Contrôleurs : traitent les requêtes. Artisan : CLI qui génère du code et lance les migrations.
Exemple simple : La route /produits de Riad pointe vers ProduitController@index, généré par Artisan.
Ce que ce n'est pas : un fichier PHP par URL bricolé à la main.
Réflexe : une URL = une route nommée vers une action claire.
- Blade (templates)
- Moteur de templates Laravel : {{ }}, @foreach, @if, layouts — avec ÉCHAPPEMENT AUTOMATIQUE (anti-XSS par défaut).
Exemple simple : Riad affiche {{ $p->nom }} sans craindre l'injection de HTML.
Ce que ce n'est pas : des echo PHP entremêlés au HTML sans échappement.
Réflexe : {{ }} par défaut ; {!! !!} seulement en connaissance de cause.
- Eloquent (ORM)
- ORM Laravel : tables ↔ classes, lignes ↔ objets ; base manipulée en objets/méthodes, requêtes préparées auto, relations élégantes.
Exemple simple : Riad lit Produit::where('prix', '>', 100)->get() au lieu d'écrire le SELECT.
Ce que ce n'est pas : du SQL concaténé avec des variables non échappées.
Réflexe : vérifier le SQL généré et chasser le N+1 avec with().
- Migrations
- Structure de la base versionnée en code PHP (avec Git) : reproductible, traçable — essentielle en équipe et au déploiement.
Exemple simple : La table produits de Riad naît d'une migration, rejouée partout à l'identique.
Ce que ce n'est pas : des ALTER TABLE faits à la main en production.
Réflexe : jamais de structure modifiée hors migration.
En pratique — En pratique — Construire avec Laravel
- Créez un projet Laravel (via Composer), explorez routes, contrôleurs, modèles, vues Blade et la CLI Artisan.
- Définissez des routes (Route::get/post) vers des contrôleurs ; créez une vue Blade avec {{ }} et @foreach (échappement automatique).
- Utilisez Eloquent : modèle + CRUD en objets (all/find/where/save) sans SQL, requêtes préparées automatiques.
- Créez une migration pour versionner une table ; activez l'auth, la validation et la protection CSRF fournies.
Script prêt à dire — défendre le passage à Laravel (30 s)
« C'est Riad : sous Laravel, nos routes sont explicites, nos vues Blade échappent par défaut, Eloquent prépare nos requêtes et nos migrations versionnent la base. On livre plus vite, avec la sécurité intégrée au lieu de la bricoler. »
À dire en point technique ; montrez route + Blade + migration.
Modèle copier-coller — CRUD Laravel (code testé)
', 100)->get();
return view('produits.index', ['produits' => $produits]);
}
public function store(Request $request) {
$valide = $request->validate(['nom' => 'required|string|max:255', 'prix' => 'required|numeric|min:0']);
$produit = Produit::create($valide);
return response()->json($produit, 201);
}
}
// resources/views/produits/index.blade.php
// @foreach ($produits as $p) {{ $p->nom }} — {{ $p->prix }} DA @endforeach
// database/migrations/xxxx_create_produits_table.php (extrait)
// Schema::create('produits', function (Blueprint $t) {
// $t->id(); $t->string('nom'); $t->decimal('prix', 10, 2); $t->timestamps();
// });
Petit site vitrine
Routes + Blade suffisent : gardez Eloquent pour ce qui mérite une base, sans sur-modéliser.
Application réelle
Comme Riad : routes nommées, contrôleurs ressources, Eloquent avec eager loading, tout en migrations.
Liste qui rame (N+1)
Chargez les relations en une fois (with('categorie')) : une requête au lieu d'une par ligne.
Équipe qui débute
Interdisez le SQL concaténé et le HTML non échappé : le framework fait déjà les deux.
validate()), laissez Blade échapper par défaut et rangez les secrets en .env, jamais en dur. Contenu pédagogique, exemples avec données fictives.✓ Bonnes pratiques
- Respecter le MVC imposé par le framework.
- Comprendre le SQL généré par Eloquent.
- Versionner la base en migrations.
✗ Pièges fréquents
- Mettre de la logique dans les templates Blade.
- Ignorer le N+1 (ORM boîte noire).
- Recoder auth/validation/CSRF déjà fournis.
Points clés à retenir
- LARAVEL = framework PHP le plus POPULAIRE : MVC, productivité, sécurité intégrée. La référence.
- ROUTAGE (Route::get → actions), CONTRÔLEURS, ARTISAN (générer, migrer).
- BLADE : {{ }}, @foreach, ÉCHAPPEMENT AUTO (anti-XSS). ELOQUENT : objets au lieu de SQL, préparées auto, relations.
- MIGRATIONS : base versionnée = reproductible et traçable. Plus auth, validation, CSRF auto.
Défi 48h — appliquez demain
Shippez 1 ressource CRUD sous Laravel : 2 routes + 1 vue Blade + Eloquent + 1 migration, sans une ligne de SQL à la main.
- Je peux citer routes, Blade, Eloquent, migrations.
- Je sais expliquer l'échappement auto et les préparées auto.
- J'ai 1 CRUD Laravel qui tourne.
Questions fréquentes
Qu'apporte un framework comme Laravel par rapport à du PHP « à la main » ?
Structure MVC imposée (fini le spaghetti), productivité (ORM, templates, routage, Artisan, dizaines de fonctionnalités prêtes), sécurité intégrée par défaut (échappement Blade anti-XSS, préparées Eloquent anti-injection, CSRF auto, hachage, auth robuste) et fonctionnalités éprouvées (auth, validation, sessions, mails, files, tests, migrations). On construit des applications complètes bien plus vite, avec moins d'erreurs — d'où son statut d'incontournable pro.
Qu'est-ce qu'un ORM comme Eloquent — et faut-il quand même connaître le SQL ?
Un ORM mappe objets ↔ tables (tables ↔ classes, lignes ↔ objets, colonnes ↔ propriétés) : Produit::all() au lieu de SELECT *. Apports : productivité, sécurité (préparées auto), lisibilité, relations élégantes ($utilisateur->commandes). Mais OUI, le SQL reste indispensable : pour comprendre et optimiser ce que l'ORM génère (N+1, index, jointures) et pour les requêtes complexes. Eloquent + bases SQL = le bon duo.
Qu'apporte Eloquent par rapport à du SQL écrit à la main ?