🛣️ Routing et Contrôleurs

Maîtriser le cœur de Symfony

Routes • Paramètres • Génération d'URLs • Request & Response

Formation DWWM - 2026

Au programme 📋

• 🗺️ Le Routing en profondeur
• 🎯 Routes avec attributs PHP
• 📝 Paramètres d'URL
• 🔗 Génération d'URLs
• 🎮 AbstractController en détail
• 📥 Request et Response
• ↩️ Redirections et Forward
• ❌ Gestion des erreurs 404

Le Routing en Profondeur

Le GPS de votre application

C'est quoi le routing ? 🗺️

Le routing est le système qui associe une URL à un contrôleur.

Cycle de vie d'une requête HTTP 🔄

Voici le parcours COMPLET d'une requête dans Symfony :

1. Utilisateur tape l'URL
   Exemple : http://localhost:8000/blog/123
2. Serveur web reçoit la requête
   Apache/Nginx intercepte et appelle index.php
3. Kernel Symfony démarre
   Charge tous les composants
4. Router analyse l'URL
   Cherche quelle route correspond à /blog/123
5. Route trouvée
   /blog/{id} → BlogController::show()
6. Contrôleur exécuté
   La méthode show($id) est appelée avec id=123
7. Réponse générée
   Le contrôleur retourne une Response
8. HTTP Response envoyée
   Le navigateur reçoit le HTML

Les 3 composants d'une route 🎯

Une route Symfony est composée de 3 éléments essentiels :

Exemple complet

#[Route('/blog/{id}', name: 'blog_show')]
public function show(int $id): Response
{
    // ...
}

// PATH: /blog/{id}
// NAME: blog_show
// CONTROLLER: BlogController::show()

Routes avec Attributs PHP

La méthode moderne

Attributs PHP 8 🆕

Depuis PHP 8 et Symfony 6, on utilise les attributs au lieu des annotations.

/**
 * @Route("/blog/{id}", name="blog_show")
 */
public function show($id)
{
    // ...
}

#[Route('/blog/{id}', name: 'blog_show')]
public function show(int $id): Response
{
    // ...
}

Syntaxe complète des attributs Route 📝

#[Route(
    path: '/blog/{id}',           // L'URL
    name: 'blog_show',            // Nom de la route
    requirements: ['id' => '\d+'], // Contraintes
    methods: ['GET'],              // Méthodes HTTP autorisées
    defaults: ['id' => 1],        // Valeurs par défaut
    priority: 0,                  // Priorité de la route
    condition: "context.getMethod() in ['GET', 'HEAD']"
)]
public function show(int $id): Response
{
    // ...
}

Routes simples (sans paramètres) 🎯

Route de base

#[Route('/', name: 'home')]
public function index(): Response
{
    return new Response('Page d\'accueil');
}

Plusieurs routes pour la même méthode

#[Route('/', name: 'home')]
#[Route('/accueil', name: 'home_alt')]
#[Route('/index', name: 'home_index')]
public function index(): Response
{
    // Accessible par 3 URLs différentes !
    return new Response('Page d\'accueil');
}

Préfixe de routes (au niveau classe) 🏷️

On peut définir un préfixe commun pour toutes les routes d'un contrôleur :

<?php
namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

#[Route('/blog')]  // ← Préfixe pour tout le contrôleur
class BlogController extends AbstractController
{
    #[Route('/', name: 'blog_index')]
    public function index(): Response
    {
        // URL finale : /blog/
    }
    
    #[Route('/{id}', name: 'blog_show')]
    public function show(int $id): Response
    {
        // URL finale : /blog/{id}
    }
    
    #[Route('/new', name: 'blog_new')]
    public function new(): Response
    {
        // URL finale : /blog/new
    }
}

Paramètres d'URL

Rendre les routes dynamiques

Paramètres simples {parametre} 📦

Les paramètres se définissent entre accolades {} dans l'URL :

Exemple : Afficher un article par ID

#[Route('/article/{id}', name: 'article_show')]
public function show(int $id): Response
{
    return new Response("Article n°" . $id);
}

// /article/5   → "Article n°5"
// /article/123 → "Article n°123"

Plusieurs paramètres 📦📦📦

On peut avoir autant de paramètres qu'on veut :

Exemple : Article d'une catégorie

#[Route('/blog/{category}/{slug}', name: 'blog_post')]
public function post(string $category, string $slug): Response
{
    return new Response(
        "Catégorie: $category, Article: $slug"
    );
}

// URL : /blog/tech/symfony-introduction
// Résultat : "Catégorie: tech, Article: symfony-introduction"

Exemple : Date dans l'URL

#[Route('/archive/{year}/{month}/{day}', name: 'archive')]
public function archive(int $year, int $month, int $day): Response
{
    return new Response(
        "Archives du $day/$month/$year"
    );
}

// URL : /archive/2025/01/28
// Résultat : "Archives du 28/01/2025"

Paramètres optionnels (avec valeur par défaut) ⚙️

Un paramètre peut avoir une valeur par défaut :

Méthode 1 : Valeur par défaut dans la méthode

#[Route('/blog/page/{page}', name: 'blog_page')]
public function page(int $page = 1): Response
{
    return new Response("Page n°$page");
}

// /blog/page/5  → "Page n°5"
// /blog/page/   → "Page n°1"  (valeur par défaut)
// /blog/page    → Erreur 404 (URL non complète)

Méthode 2 : Valeur par défaut dans l'attribut Route

#[Route('/blog/{page}', name: 'blog_page', defaults: ['page' => 1])]
public function page(int $page): Response
{
    return new Response("Page n°$page");
}

// /blog/5  → "Page n°5"
// /blog    → "Page n°1"  (valeur par défaut)

Requirements - Contraintes sur les paramètres 🔒

On peut forcer un paramètre à respecter un format avec requirements :

Contraindre à des chiffres uniquement

#[Route('/article/{id}', name: 'article_show', requirements: ['id' => '\d+'])]
public function show(int $id): Response
{
    // $id sera TOUJOURS un nombre
}

// ✅ /article/123  → OK
// ❌ /article/abc  → 404

Contraindre à un format slug

#[Route('/blog/{slug}', name: 'blog_post', requirements: ['slug' => '[a-z0-9-]+'])]
public function post(string $slug): Response
{
    // Accepte seulement lettres minuscules, chiffres et tirets
}

// ✅ /blog/mon-article-123  → OK
// ❌ /blog/Mon_Article!     → 404

Contraindre à des valeurs spécifiques

#[Route('/langue/{locale}', name: 'change_locale', 
    requirements: ['locale' => 'fr|en|es'])]
public function changeLocale(string $locale): Response
{
    // Accepte SEULEMENT : fr, en, es
}

// ✅ /langue/fr  → OK
// ✅ /langue/en  → OK
// ❌ /langue/de  → 404

Regex courantes pour requirements 📋

Méthodes HTTP autorisées 🔐

On peut limiter une route à certaines méthodes HTTP :

Route GET uniquement

#[Route('/article/{id}', name: 'article_show', methods: ['GET'])]
public function show(int $id): Response
{
    // Accessible SEULEMENT en GET
}

Route POST uniquement (formulaire)

#[Route('/article/create', name: 'article_create', methods: ['POST'])]
public function create(Request $request): Response
{
    // Accessible SEULEMENT en POST
}

GET et POST

#[Route('/contact', name: 'contact', methods: ['GET', 'POST'])]
public function contact(Request $request): Response
{
    if ($request->isMethod('POST')) {
        // Traiter le formulaire
    }
    // Afficher le formulaire
}

Génération d'URLs

Ne jamais écrire d'URLs en dur

Pourquoi générer les URLs ? 🤔

<a href="/blog/123">Article</a>

<!-- Si tu changes la route en /article/123,
     tous tes liens sont cassés ! -->

<a href="{{ path('blog_show', {id: 123}) }}">
    Article
</a>

<!-- Si tu changes l'URL, les liens
     se mettent à jour automatiquement ! -->

path() dans Twig 🎨

La fonction path() génère une URL relative :

Route sans paramètres

{{ path('home') }}
{# Génère : / #}

<a href="{{ path('home') }}">Accueil</a>

Route avec 1 paramètre

{{ path('blog_show', {id: 123}) }}
{# Génère : /blog/123 #}

<a href="{{ path('blog_show', {id: article.id}) }}">
    Lire l'article
</a>

Route avec plusieurs paramètres

{{ path('blog_post', {category: 'tech', slug: 'symfony-intro'}) }}
{# Génère : /blog/tech/symfony-intro #}

<a href="{{ path('blog_post', {
    category: article.category,
    slug: article.slug
}) }}">
    {{ article.title }}
</a>

url() vs path() dans Twig 🔗

Exemples pratiques

{# Lien interne - utilise path() #}
<a href="{{ path('contact') }}">Contactez-nous</a>

{# Email - utilise url() #}
<p>Consultez cet article : {{ url('blog_show', {id: 123}) }}</p>

{# Open Graph (réseaux sociaux) - utilise url() #}
<meta property="og:url" content="{{ url('blog_show', {id: article.id}) }}">

Générer des URLs dans le contrôleur 🎮

Dans un contrôleur, on utilise $this->generateUrl() :

URL relative

$url = $this->generateUrl('blog_show', ['id' => 123]);
// Résultat : /blog/123

URL absolue

use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

$url = $this->generateUrl(
    'blog_show',
    ['id' => 123],
    UrlGeneratorInterface::ABSOLUTE_URL
);
// Résultat : http://localhost:8000/blog/123

Exemple : Envoyer un email avec lien

public function sendEmail(MailerInterface $mailer): Response
{
    $articleUrl = $this->generateUrl(
        'blog_show',
        ['id' => 123],
        UrlGeneratorInterface::ABSOLUTE_URL
    );
    
    $email = (new Email())
        ->to('user@example.com')
        ->subject('Nouvel article')
        ->html("Lire l'article : <a href='$articleUrl'>Cliquez ici</a>");
    
    $mailer->send($email);
    
    return new Response('Email envoyé !');
}

AbstractController

Votre boîte à outils

C'est quoi AbstractController ? 🧰

AbstractController est la classe parent de tous vos contrôleurs. Elle fournit des méthodes utiles.

Méthodes essentielles d'AbstractController 🛠️

render() - Rendre un template 🎨

La méthode render() génère du HTML à partir d'un template Twig.

Syntaxe complète

$this->render(
    string $view,              // Chemin du template
    array $parameters = [],    // Variables à passer
    ?Response $response = null // Response existante (rare)
): Response

Exemples

// Template simple
return $this->render('home/index.html.twig');

// Avec variables
return $this->render('blog/show.html.twig', [
    'article' => $article,
    'comments' => $comments
]);

// Modifier le statut HTTP
return $this->render('error.html.twig', [], 
    new Response('', 500)
);

json() - Retourner du JSON 📊

La méthode json() convertit automatiquement des données PHP en JSON.

Syntaxe

$this->json(
    mixed $data,           // Données à convertir
    int $status = 200,     // Code HTTP
    array $headers = [],   // Headers personnalisés
    array $context = []    // Options de serialization
): JsonResponse

Exemples

// Tableau simple
return $this->json(['message' => 'Success', 'data' => [1, 2, 3]]);

// Objet
return $this->json($user);

// Avec statut HTTP personnalisé
return $this->json(['error' => 'Not found'], 404);

// Avec headers CORS
return $this->json($data, 200, [
    'Access-Control-Allow-Origin' => '*'
]);

Request et Response

Communication client-serveur

L'objet Request 📨

Request contient TOUTES les informations de la requête HTTP entrante.

Propriétés de l'objet Request 📋

Récupérer des données GET 📥

Les paramètres GET viennent de l'URL après le ?

URL : /search?q=symfony&page=2

use Symfony\Component\HttpFoundation\Request;

#[Route('/search', name: 'search')]
public function search(Request $request): Response
{
    // Récupérer un paramètre
    $query = $request->query->get('q');
    $page = $request->query->get('page');
    
    // Avec valeur par défaut
    $limit = $request->query->get('limit', 10);
    
    // Tous les paramètres GET
    $allParams = $request->query->all();
    
    return new Response("Recherche: $query, Page: $page");
}

// URL : /search?q=symfony&page=2
// Résultat : "Recherche: symfony, Page: 2"

Récupérer des données POST 📮

Les paramètres POST viennent d'un formulaire soumis.

#[Route('/login', name: 'login', methods: ['GET', 'POST'])]
public function login(Request $request): Response
{
    if ($request->isMethod('POST')) {
        // Récupérer les champs du formulaire
        $email = $request->request->get('email');
        $password = $request->request->get('password');
        
        // Traiter le login...
        return new Response("Login: $email");
    }
    
    // Afficher le formulaire
    return $this->render('login.html.twig');
}

Vérifier la méthode HTTP

if ($request->isMethod('POST')) { /* ... */ }
if ($request->isMethod('GET')) { /* ... */ }

// Ou
$method = $request->getMethod(); // 'GET', 'POST', etc.

Récupérer les headers HTTP 📨

// User-Agent
$userAgent = $request->headers->get('User-Agent');

// Accept-Language
$language = $request->headers->get('Accept-Language');

// Referer (page précédente)
$referer = $request->headers->get('referer');

// Content-Type
$contentType = $request->headers->get('Content-Type');

// Tous les headers
$allHeaders = $request->headers->all();

Cas pratique : Détecter le navigateur

public function detectBrowser(Request $request): Response
{
    $userAgent = $request->headers->get('User-Agent');
    
    if (str_contains($userAgent, 'Chrome')) {
        $browser = 'Google Chrome';
    } elseif (str_contains($userAgent, 'Firefox')) {
        $browser = 'Mozilla Firefox';
    } else {
        $browser = 'Autre navigateur';
    }
    
    return new Response("Vous utilisez : $browser");
}

L'objet Response 📤

Response est ce que vous renvoyez au client (navigateur).

HTTP/1.1 200 OK                    ← Statut HTTP
Content-Type: text/html            ← Headers
Set-Cookie: session=abc123
                                   ← Ligne vide
<html>                             ← Body (contenu)
  <body>Hello World</body>
</html>

Créer une Response simple

use Symfony\Component\HttpFoundation\Response;

return new Response(
    '<html><body>Hello</body></html>',  // Contenu
    200,                                      // Statut HTTP
    ['Content-Type' => 'text/html']          // Headers
);

Codes de statut HTTP 🔢

Types de Response spécialisées 🎭

1. Response HTML classique

return new Response('<h1>Hello</h1>');

2. JsonResponse (API)

use Symfony\Component\HttpFoundation\JsonResponse;

return new JsonResponse(['message' => 'Success', 'data' => [1, 2, 3]]);

3. RedirectResponse

use Symfony\Component\HttpFoundation\RedirectResponse;

return new RedirectResponse('https://google.com');

4. BinaryFileResponse (téléchargement)

use Symfony\Component\HttpFoundation\BinaryFileResponse;

return new BinaryFileResponse('/path/to/document.pdf');

5. StreamedResponse (gros fichiers)

use Symfony\Component\HttpFoundation\StreamedResponse;

return new StreamedResponse(function() {
    echo 'Chunk 1';
    flush();
    sleep(1);
    echo 'Chunk 2';
});

Redirections et Forward

Naviguer entre les pages

redirectToRoute() - Redirection vers une route 🔄

La méthode la plus courante pour rediriger :

Syntaxe

$this->redirectToRoute(
    string $route,           // Nom de la route
    array $parameters = [],  // Paramètres de la route
    int $status = 302        // Code HTTP (302 par défaut)
): RedirectResponse

Exemples

// Redirection simple
return $this->redirectToRoute('home');

// Avec paramètres
return $this->redirectToRoute('blog_show', ['id' => 123]);

// Redirection permanente (301)
return $this->redirectToRoute('new_url', [], 301);

Cas pratique : Après création d'article

#[Route('/article/create', name: 'article_create', methods: ['POST'])]
public function create(Request $request): Response
{
    // Créer l'article...
    $articleId = 123;
    
    // Rediriger vers la page de l'article créé
    return $this->redirectToRoute('article_show', ['id' => $articleId]);
}

redirect() - Redirection vers une URL 🌐

Pour rediriger vers une URL externe ou complète :

Exemples

// Vers un site externe
return $this->redirect('https://www.google.com');

// Vers une URL relative
return $this->redirect('/old-page');

// Génération d'URL puis redirection
$url = $this->generateUrl('blog_show', ['id' => 123]);
return $this->redirect($url);

Redirection 301 vs 302 🔀

Exemples

// 302 - Temporaire (par défaut)
return $this->redirectToRoute('home');

// 301 - Permanente
return $this->redirectToRoute('new_home', [], 301);

Gestion des erreurs 404

Quand la ressource n'existe pas

createNotFoundException() 🚫

Lance une exception qui génère une page 404 :

Syntaxe

throw $this->createNotFoundException(string $message = 'Not Found');

Exemple : Article introuvable

#[Route('/article/{id}', name: 'article_show')]
public function show(int $id): Response
{
    $article = $this->getArticleById($id);
    
    if (!$article) {
        throw $this->createNotFoundException(
            'Article n°' . $id . ' introuvable'
        );
    }
    
    return $this->render('article/show.html.twig', [
        'article' => $article
    ]);
}

Personnaliser la page 404 🎨

Créez un template personnalisé pour vos erreurs 404 :

Créer le template

📄 templates/bundles/TwigBundle/Exception/error404.html.twig

{% extends 'base.html.twig' %}

{% block title %}Page non trouvée{% endblock %}

{% block body %}
    <div style="text-align: center; padding: 4rem;">
        <h1 style="font-size: 6rem; color: #dc3545;">404</h1>
        <h2>Page non trouvée</h2>
        <p>La page que vous recherchez n'existe pas.</p>
        <a href="{{ path('home') }}">Retour à l'accueil</a>
    </div>
{% endblock %}

Ce qu'on a appris

Résumé complet 📚

Points clés à retenir 🎯

1. Toujours nommer vos routes
   Le name est obligatoire pour générer des URLs
2. Utilisez path() pour les URLs
   Jamais d'URLs en dur comme /blog/123
3. Contraignez vos paramètres
   requirements protège contre les valeurs invalides
4. Request contient TOUT
   GET, POST, headers, cookies, files...
5. Héritez d'AbstractController
   Accès aux méthodes render(), json(), etc.
6. Redirigez après POST
   Pattern POST-Redirect-GET pour éviter la double soumission
7. Gérez les 404 proprement
   createNotFoundException() + template personnalisé

Commandes utiles 🛠️

Exemple de debug

# Voir les détails d'une route
php bin/console debug:router blog_show

# Résultat :
# Name         blog_show
# Path         /blog/{id}
# Controller   App\Controller\BlogController::show()
# Requirements id: \d+
# Methods      GET

Erreurs courantes à éviter ⚠️

#[Route('/blog')]  // ❌ Pas de name
public function index() { }

#[Route('/blog', name: 'blog_index')]  // ✅ Avec name
public function index() { }

<a href="/blog/123">Article</a>  {# ❌ #}

<a href="{{ path('blog_show', {id: 123}) }}">Article</a>  {# ✅ #}

#[Route('/blog/{id}')]  // ❌ Accepte /blog/abc
public function show($id) { }

#[Route('/blog/{id}', requirements: ['id' => '\d+'])]  // ✅
public function show(int $id) { }

Bonnes pratiques 💡

1. Préfixez vos noms de routes
   blog_index, blog_show, blog_create
2. Groupez par fonctionnalité
   Un contrôleur par ressource (Blog, User, Product...)
3. Utilisez les méthodes HTTP
   GET pour lire, POST pour créer, PUT pour modifier, DELETE pour supprimer
4. Validez TOUJOURS les paramètres
   Requirements + vérification que la ressource existe
5. Typez vos paramètres
   int $id au lieu de $id
6. Séparez logique et présentation
   Logique dans le contrôleur, HTML dans Twig
7. Gérez les cas d'erreur
   404, 403, 500... toujours prévoir le pire !

Ressources pour aller plus loin 📚

🎓 Bravo !

Vous maîtrisez le Routing et les Contrôleurs

Prochaine étape : Twig ! 🎨

Formation DWWM - 2026