User Tools

Site Tools


backend:symfonyproject

Symfony : Le projet

logo

Création d'un projet

Créer un projet

Voir la documentation officielle : Creating Symfony Applications

Projet micro framework, avec juste la base

symfony new my_project_name
# ou
composer create-project symfony/skeleton my_project_name

Projet monolithique, pour une application web

symfony new my_project_name --full
# ou
composer create-project symfony/website-skeleton my_project_name

Ouverture d'un projet dans le navigateur

symfony open:local

Structure d'un projet

Un projet est composer de plusieurs répértoires et fichiers.

Répertoire : bin

Il contient les fichiers “binaires”

Fichier : console.php

C'est le fichier qu'on va appeler avec la commande :

php console/bin

On peut indiquer directement que ce fichier s'ouvre avec l'interpréteur de commandes PHP en ajoutant #!/usr/bin/env php au début du fichier pour ne plus à avoir à taper php devant console\bin.

On peut aussi l'appeler avec la commande :

symfony console

Répertoire : config

Il contient les fichiers de configurations

Modification de la timezone

Dans le fichier config\packages\twig.yaml, on peut configurer la timezone pour l'affichage Twig :

twig:
    date:
      timezone: Europe/Paris

La méthode date_default_timezone_get() renvoie la timezone actuelle.

On peut aussi la modifier en créant un fichier php.ini à la racine du projet et en mettant dedans :

[Date]
date.timezone = Europe/Paris

En le faisant dans le fichier php.ini, on n'a plus à le faire ailleurs, c'est très pratique.

Répertoire : public

Il contient les fichiers publics

Répertoire : src

Il contient les fichiers de codes sources :entités, contrôleurs, dépôts, formulaires …

Répertoire : templates

Répertoire : tests

Répertoire : translations

Répertoire : var

Il contient les fichiers temporaires, les logs et le cache

Répertoire : vendor

Il contient les dépendances, les packages, les bundles (ce sont des plugins), voir la section bundles plus bas.

Fichier : .env

Il permet de gérer les variables d'environnement

Controller

Un controller est une classe, donc son nom commence par une majuscule

Création : make:controller

symfony console make:controller

On donne alors un nom au controller : PinsController

Par convention, on utilise la syntaxe CamelCase : PinsController

On peut aussi directement donner le nom :

symfony console make:controller PinsController

On peut aussi ne pas mettre Controller dans le nom, Symfony l'ajoutera automatiquement :

symfony console make:controller Pins

Si on ne veut pas que Symfony crée un template associé on peut ajouter –no-template:

symfony console make:controller Pins --no-template

Lorsque le controller est créé, 2 fichiers sont créés :
src\Controller\PinsController.php
templates\pins\index.html.twig

Actions

Les actions sont les méthodes publiques du controller.On peut leur ajouter des annotations (des métadonnées).

Elles doivent toujours retourner un objet de type Response (Symfony\Component\HttpFoundation\Response)

Routes

Déclaration

On peut déclarer les routes dans les annotations des actions ou directement dans le fichier config\routes.yaml

Symfony applique les routes de haut en bas dans le code

On peut voir toutes les routes en faisant :

symfony console debug:router

Pour mettre une route dans les annotations d'une action, on utilise :

/**
  * @Route("/")
  */

Il faut utiliser uniquement des dans les annotations.

Méthodes de requête HTTP

Liste des méthodes de requête HTTP

Méthode Description
CONNECT établit un tunnel vers le serveur identifié par la ressource cible
DELETE supprime la ressource indiquée
GET demande une représentation de la ressource spécifiée. Les requêtes GET doivent uniquement être utilisées afin de récupérer des données
HEAD demande une réponse identique à une requête GET pour laquelle on aura omis le corps de la réponse (on a uniquement l'en-tête)
OPTIONS est utilisée pour décrire les options de communications avec la ressource visée
PATCH est utilisée pour appliquer des modifications partielles à une ressource
POST est utilisée pour envoyer une entité vers la ressource indiquée. Cela entraîne généralement un changement d'état ou des effets de bord sur le serveur, après généralement on redirige l'utilisateur pour que les formulaires ne puissent pas être renvoyés.
PUT remplace toutes les représentations actuelles de la ressource visée par le contenu de la requête
TRACE réalise un message de test aller/retour en suivant le chemin de la ressource visée

On peut indiquer les méthodes de requêtes HTTP supportées par la route, par défaut toutes les méthodes sont utilisées.
On peut le faire sous forme de tableau :

/**
  * @Route("/", methods={"GET", "POST"})
  */

Ou sous forme de chaine de caractères :

/**
  * @Route("/", methods="GET|POST")
  */

On peut aussi récupérer le type de méthode utilisée en utilisant un objet de type Request(Symfony\Component\HttpFoundation\Request) et la méthode isMethod :

public function create(Request $request)
{
  if ($request->isMethod('POST')) {
    // ... traitement
  }
  return $this->render('pins/create.html.twig');
}

Pour récupérer $_GET :

$request->query

Pour récupérer $_POST :

$request->request

On récupère alors un objet de type ParameterBag qui possède les méthodes suivantes :

  • all : retourne l'ensemble des éléments
  • keys : retourne uniquement les clés
  • get : retourne un élément par son nom
  • set : affecte un élément par son nom
  • has : voir si un élément est défini
  • getBoolean, getAlpha, getAlnum, getDigits, getInt : retourne la conversion de l'élément
  • getIterator : retourne un iterator
  • count : retourne le nombre d'éléments
  • add : ajoute des éléments
  • replace : remplace les éléments
  • remove : supprime un élément
  • filter : iltre les éléments

On peut alors récupérer les données :

public function create(Request $request)
{
  if ($request->isMethod('POST')) {
    $data = $request->request->all();
  }
}

Nom de routes

On voir les noms des routes en faisant :

symfony console debug:router
Noms générés automatiquement

Symfony affecte un nom à chaque route que l'on crée, sous la forme :

app_
nom_du_controller(sans Controller)_
nom_de_la_méthode

Par exemple :
PinsController avec méthode index() donne : app_pins_index

Noms personnalisés

On peut affecter un nom spécifique aux routes en utilisant name :

/**
  * @Route("/", name="app_home")
  */

Commande router:match

Pour avoir des informations sur une route :

symfony console router:match chemin_de_la_route

Routes dynamiques

On peut ajouter des paramètres dans les routes (dits paramètres de route) pour les rendre dynamiques.
Il faut ajouter le nom du paramètre entre { } dans la route et utiliser le même nom avec $ devant pour un paramètre de la méthode correspondant, on peut alors utiliser cette variable dans la méthode.

/**
  * @Route("/pins/{id}")
  */
public function show(PinRepository $repo, $id)
{
  $pin = $repo->find($id);
 
  return $this->render('pins/show.html.twig', compact('pin'));
}

On peut demander à ce que le paramètre de la route soit particulier grace aux expressions régulières, les requirements (indiqués entre les < >) :

  /**
   * @Route("/pins/{id<[0-9]+>}")
   */

Depuis Symfony 5.1, on utilise des priorités pour les routes.
Par défaut la valeur de la priorité est 0, on peut utiliser des priorité positives et négatives grace à priority :

  /**
   * @Route("/pins/{id}, priority=-10")
   */

On avance de 10 en 10 pour les priorités pour pouvoir facilement ajouter des routes entre.

Si la route n'est pas trouvée, une réponse 500 sera envoyée.

Générer une réponse 404

On peut générer une réponse 404 en lançant une exception avec la méthode createNotFoundException() à laquelle on peut passer un message :

/**
  * @Route("/pins/{id<[0-9]+>}")
  */
public function show(PinRepository $repo, int $id)
{
  $pin = $repo->find($id);
 
  if (!$pin) {
    throw $this->createNotFoundException('Pin  n°' . $id . ' not found');
  }
 
  return $this->render('pins/show.html.twig', compact('pin'));
}

On peut injecter en paramètre avec le type d'un objet et Symfony va rechercher un objet de ce type avec l'id de la route, si la route n'est pas trouvée, une réponse 404 sera directement envoyée :

/**
  * @Route("/pins/{id<[0-9]+>}")
  */
public function show(Pin $pin)
{
  return $this->render('pins/show.html.twig', compact('pin'));
}

La méthode redirectToRoute accepte aussi des paramètres :

/**
  * @Route("/pins/create", name="app_pins_create", methods="GET|POST")
  */
public function create(Request $request, EntityManagerInterface $em)
{
  $pin = new Pin;
 
  $form = $this->createFormBuilder($pin)
    ->add('title', null, ['attr' => ['autofocus' => true]])
    ->add('description', null, ['attr' => ['rows' => 10, 'cols' => 50]])
    ->getForm();
 
  $form->handleRequest($request);
 
  if ($form->isSubmitted() && $form->isValid()) {
    $em->persist($pin);
    $em->flush();
 
    return $this->redirectToRoute('app_pins_show', ['id' => $pin->getId()]);
  }
 
  return $this->render('pins/create.html.twig', [
    'monFormulaire' => $form->createView()
  ]);
}
backend/symfonyproject.txt · Last modified: 2020/09/16 10:35 (external edit)