Gérer l'objet `Request` pour accéder aux données de la requête

Introduction à l'objet `Request` : votre source d'information HTTP

Lorsqu'un client (généralement un navigateur web) envoie une requête à votre application Symfony, cette requête contient une multitude d'informations : l'URL demandée, les paramètres GET, les données de formulaire POST, les en-têtes HTTP, les cookies, les fichiers uploadés, etc. Symfony encapsule toutes ces informations dans un objet unique et pratique : l'objet Symfony\Component\HttpFoundation\Request.

Cet objet Request est créé très tôt dans le cycle de vie de la requête par le noyau (Kernel) de Symfony, avant même que le routage ne soit effectué. Il est ensuite transmis à travers les différents composants, y compris votre contrôleur. Avoir accès à cet objet est crucial pour que votre contrôleur puisse comprendre ce que le client demande et agir en conséquence.

Plutôt que de travailler directement avec les superglobales PHP ($_GET, $_POST, $_SERVER, etc.), qui peuvent être sources d'incohérences et de problèmes de sécurité, Symfony vous encourage fortement à utiliser l'objet Request. Il offre une API orientée objet, plus propre, plus testable et plus sécurisée pour accéder à toutes les facettes de la requête HTTP entrante.

Comment obtenir l'objet `Request` dans un contrôleur

Dans Symfony, la manière la plus simple et la plus courante d'obtenir l'objet Request au sein d'une méthode d'action de votre contrôleur est de le déclarer comme argument de cette méthode, en utilisant le type-hint Symfony\Component\HttpFoundation\Request. Grâce au système d'injection de dépendances et à l' résolveur d'arguments de contrôleur de Symfony, l'objet Request actuel sera automatiquement injecté lorsque votre action sera appelée.

headers->get('User-Agent');
        $paramGet = $request->query->get('nom', 'valeur_par_defaut'); // Accès à un paramètre GET

        return new Response(
            "User-Agent: " . htmlspecialchars($userAgent) .
            "
Paramètre 'nom': " . htmlspecialchars($paramGet) . ""
        );
    }
}

Il n'est pas nécessaire de faire quoi que ce soit de plus. Symfony s'occupe de vous fournir l'instance correcte de Request. C'est la méthode privilégiée car elle rend la dépendance explicite et facilite les tests unitaires de vos contrôleurs (vous pouvez facilement créer un mock de l'objet Request).

Notez que si votre action a aussi des paramètres de route (comme {id}), vous pouvez les combiner :

    #[Route('/article/{id}', name: 'app_article_detail')]
    public function detailArticle(Request $request, int $id): Response
    {
        // $request et $id sont disponibles
        // ...
    }

Accéder aux différentes données de la requête

L'objet Request possède plusieurs propriétés publiques, qui sont elles-mêmes des objets (appelés "ParameterBags"), fournissant un accès structuré aux différentes parties de la requête :

• $request->query : Pour les paramètres de la chaîne de requête ($_GET). C'est un objet de type ParameterBag.
• $request->request : Pour les paramètres envoyés dans le corps d'une requête POST ($_POST). Aussi un ParameterBag.
• $request->attributes : Pour les attributs de la requête, qui incluent notamment les paramètres de route (comme {id}). C'est un ParameterBag. Notez que les paramètres de route sont généralement injectés directement comme arguments de la méthode d'action, ce qui est plus direct.
• $request->cookies : Pour les valeurs des cookies ($_COOKIE). Un ParameterBag.
• $request->files : Pour les informations sur les fichiers uploadés ($_FILES). C'est un objet de type FileBag.
• $request->server : Pour les variables du serveur ($_SERVER). Un ServerBag.
• $request->headers : Pour les en-têtes de la requête. C'est un objet de type HeaderBag.

Chacun de ces "bags" (sacs de paramètres) offre des méthodes utiles comme get(), has(), all(), getInt(), etc., pour récupérer les données de manière sûre.

Exemples d'utilisation :

// Récupérer un paramètre GET 'search'
$searchTerm = $request->query->get('search');

// Récupérer un paramètre POST 'username', avec une valeur par défaut si absent
$username = $request->request->get('username', 'anonyme');

// Vérifier si un paramètre GET 'page' existe
if ($request->query->has('page')) {
    $page = $request->query->getInt('page'); // Récupère comme entier
}

// Récupérer tous les paramètres POST
$allPostData = $request->request->all();

// Accéder à un en-tête HTTP (les noms sont normalisés en minuscules avec tirets)
$contentType = $request->headers->get('Content-Type');

// Accéder à l'adresse IP du client
$clientIp = $request->getClientIp(); // Méthode pratique sur l'objet Request lui-même

// Vérifier si la requête est une requête AJAX (XMLHttpRequest)
if ($request->isXmlHttpRequest()) {
    // Logique spécifique pour AJAX
}

// Obtenir la méthode HTTP de la requête (GET, POST, PUT, etc.)
$method = $request->getMethod(); // ex: 'POST'

// Obtenir le chemin de l'URL demandée (ex: /mon-article/42)
$pathInfo = $request->getPathInfo();

L'utilisation de ces méthodes est préférable à l'accès direct aux superglobales car elles offrent une couche d'abstraction, une meilleure gestion des cas où le paramètre n'existe pas (via les valeurs par défaut), et une meilleure testabilité.

Gérer les fichiers uploadés avec `FileBag`

Lorsque votre formulaire HTML contient un champ de type , les informations sur le fichier uploadé sont accessibles via la propriété $request->files. Cette propriété est un objet de type Symfony\Component\HttpFoundation\FileBag.

Pour récupérer un fichier uploadé, vous utilisez la méthode get() du FileBag, en lui passant le nom de votre champ input. Cette méthode retourne un objet de type Symfony\Component\HttpFoundation\File\UploadedFile (ou null si aucun fichier n'a été uploadé pour ce champ).

use Symfony\Component\HttpFoundation\File\UploadedFile;

// ... dans une action de contrôleur ...
public function handleUpload(Request $request): Response
{
    /** @var UploadedFile|null $uploadedFile */
    $uploadedFile = $request->files->get('mon_fichier');

    if ($uploadedFile) {
        // Le fichier a bien été uploadé
        $originalFilename = pathinfo($uploadedFile->getClientOriginalName(), PATHINFO_FILENAME);
        $safeFilename = transliterator_transliterate('Any-Latin; Latin-ASCII; [^A-Za-z0-9_] remove; Lower()', $originalFilename);
        $newFilename = $safeFilename.'-'.uniqid().'.'.$uploadedFile->guessExtension();

        // Déplacer le fichier vers le répertoire où vous souhaitez le stocker
        try {
            $uploadedFile->move(
                $this->getParameter('dossier_uploads'), // Paramètre configuré dans services.yaml
                $newFilename
            );
        } catch (FileException $e) {
            // Gérer l'exception si quelque chose se passe mal pendant le déplacement
            // par exemple, afficher un message d'erreur
        }

        // $newFilename contient maintenant le nom du fichier stocké sur le serveur
        // Vous pouvez enregistrer ce nom en base de données, etc.
        return new Response("Fichier uploadé avec succès : " . $newFilename);
    } else {
        // Aucun fichier n'a été soumis, ou une erreur s'est produite avant
        return new Response("Aucun fichier n'a été uploadé.", Response::HTTP_BAD_REQUEST);
    }
}

L'objet UploadedFile offre plusieurs méthodes utiles :

• getClientOriginalName(): Retourne le nom original du fichier tel qu'il était sur l'ordinateur du client.
• getClientMimeType(): Retourne le type MIME du fichier tel que fourni par le client (ne pas s'y fier aveuglément pour la sécurité).
• guessExtension(): Tente de deviner l'extension du fichier à partir de son type MIME.
• getSize(): Retourne la taille du fichier en octets.
• isValid(): Vérifie si le fichier a été uploadé via HTTP POST et sans erreur. Il est crucial de vérifier cela.
• move(string $directory, string $name = null): Déplace le fichier uploadé (qui est temporairement stocké quelque part par PHP) vers un nouvel emplacement permanent. C'est l'étape essentielle pour sauvegarder le fichier.

Il est très important de toujours valider les fichiers uploadés (taille, type MIME, extension) et de générer des noms de fichiers uniques et sécurisés avant de les stocker sur votre serveur pour éviter des problèmes de sécurité (comme l'écrasement de fichiers existants ou l'upload de fichiers malveillants).