L’utilisation d’un framework PHP permet de faciliter la création d’un site/CRUD.
Pendant ma formation, j’ai enfin découvert Symfony 5 !
Symfony, qu’est ce que c’est ?
Comme je l’ai dit, Symfony est un framework PHP. C’est donc un logiciel de construction ou une grosse boite à outils permettant d’aller plus vite.
On y trouve :
– un router : Symfony vient avec son propre serveur web
– des templates
– une structure de projet MVC
– la construction de classes et d’objets facilitée grâce à de nombreuses conventions (notions avancées déjà configurées, qu’on peut implémenter facilement, et qu’il ne faudra pas hésiter à tester !)
Utilisation de Symfony
Créer un nouveau projet
Pour créer un nouveau projet, on utilise alors la commande suivante :
composer create-project symfony/website-skeleton blog
Elle permet de créer toute une architecture de projet sur la base de paquet (ici website-skeleton) dans le dossier choisi.
Il existe 2 types de projets :
– skeleton : projet basique sans dépendances. Principalement utilisé pour API, ou pour avancer finement sur un projet.
– website-skeleton : projet avec tout le nécessaire pour partir direct avec serveur intégré.
A noter que lorsque l’on utilise un framework, il ne faut pas lui faire confiance à 100% et bien vérifier les fichiers (pour éviter des bugs). Il est donc important de bien lire tous les messages qui apparaissent sur le terminal à la suite d’une installation car ils contiennent de nombreuses informations inintéressantes.
Je vous mets ici une liste pour connaitre un peu plus en détail certains fichiers :
– composer.lock : c’est la liste des versions actuelles des extensions utilisées par le projet. Attention : il ne doit jamais être touché !
– symfony.doc : c’est la documentation à ne pas toucher;
– Kernel : c’est le noyau du projet, on ne le touche pas. A notre niveau, il n’y a pas besoin de le connaitre pour travailler.
– Entity : c’est un Model avec juste les attributs, les getter et les setter
– repository : ce sont les fichiers qui permettent de faire des select dans un Model. Les requêtes st donc externalisées.
– migration : ce fichier contient les modifications successives que l’on fait dans la Base de Données.
Routes
Avec Symfony, il y a deux façons différentes de déclarer les routes :
– soit dans un fichier en .yaml
# config/routes.yaml
about:
path: /a-propos
controller: App\Controller\PagesController::about
Dans ce cas on indique à Symfony que la route about se dirigera vers le controller PagesController et utilisera la méthode about associée, lorsque l’utilisateur va sur l’URL /a-propos .
– soit en utilisant les commentaires pour définir les routes directement dans le controller. Attention, il faut bien définir dans l’ordre : la route puis son nom. (voir plus loin dans l’explication des controller)
C’est donc ce choix qu’on privilégiera.
Attention, les 2 façons de faire ne sont pas compatibles !
Controller
Le controller est ensuite créé dans le dossier src/ :
// src/Controller/PagesController.php
namespace App\Controller;
use Symfony\Component\HttpFoundation\Response;
class PagesController {
public function about() {
return new Response('Hello world!');
}
}
Toutes les méthodes de controller retournent impérativement une Response . On utilisera donc l’autocomplétion pour bien importer les alias nécessaires!
return new Response();
C’est alors à ce moment que l’on peut déclarer les routes via les commentaires :
use Symfony\Component\Routing\Annotation\Route;
// ...
/**
* @Route("/home", name="home")
*/
public function home() {
return new Response ('Bienvenue sur la page d\'accueil !');
}
Lors de la déclaration des routes, il est possible d’ajouter des variables dans l’URL. La documentation de Symfony est très bien fournie !
/**
* @Route("/users/{userId}/books/{bookId}", name="user_book")
*/
public function users(int $userId, int $bookId) {
return new Response ('Vous consultez le livre #' . $bookId . ' de l\'utilisateur numéro '. $userId);
}
Il est possible de typer ces variables pour n’accepter que certains types de caractères. Pour cela on va utiliser des expressions régulières (ou regex)
/**
* @Route("/blog/{page}", name="blog_list", requirements={"page"="\d+"})
*/
Dans ce cas-là, la route n’acceptera que les cas où l’argument {page} correspond à la regex \d+ (= valeurs numériques uniquement).
Note :
Avec Symfony, le var_dump ne permet plus de voir de façon simple les informations. A la place, on fera un dd (dump & die).
Requête (et Réponse)
Lorsque l’on a besoin de récupérer des données d’une requête, on utilise les Request et Response du package HttpFoundation.
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
// ...
/**
* @Route("/post-user", name="create_user", methods={"POST"})
*/
public function create(Request $request) : Response
{
dump($request);
}
Nous avons donc déclaré dans la route quelle méthode nous utilisons pour « communiquer » avec la basse de données (ici c’est la méthode POST).
Nous avons aussi importé les classes Request et Response, ce qui nous a permis d’utiliser l’objet Request dans la méthode create().
Il ne faut alors pas oublier d’indiquer le type de retour de la fonction (: Response).
L’objet Request $request, qui par exemple peut être issu de l’envoi d’un formulaire, est alors disponible à l’utilisation !
Nous pouvons ensuite accéder aux valeurs POST par exemple avec $request->get('name');.
Communication avec la base de données
Pour créer une base de données lors d’un projet Symfony, on va utiliser Doctrine.
Doctrine est un ORM (Object-Relational Mapper), qui implémente le pattern Data Mapper. Concrètement, le Data Mapper synchronise un objet dans le PHP avec la base de données, ce qui nous donne une couche Model performante dans notre MVC.
Pour commencer, il faut configurer la base de données dans le fichier .env qui se trouve à la racine du projet :
DATABASE_URL=mysql://db_user:db_password@127.0.0.1:3306/db_name
NB : Remplacez les valeurs de db_user et db_password par les valeurs qui correspondent à votre configuration.
Une fois le fichier .env configuré, on ouvre une console dans le dossier du projet dans laquelle on va saisir : php bin/console doctrine:database:create pour créer la base de données.
Ensuite on va créer une Entity (équivalent du Model en MVC – qui mappera la table correspondante en base de données), en saisissant dans la console : php bin/console make:entity Article
Puis il faut effectuer une migration. Une migration est en fait une instruction de base de données qui indique quoi faire par rapport à l’état des fichiers Entity (elle regarde la BdD et l’Entity puis vérifie la différence entre les deux).
php bin/console make:migration
Il faut ensuite bien aller voir la migration pour vérifier la ligne SQL (et la modifier si nécessaire !). Si tout est OK, on valide en lançant la commande : php bin/console doctrine:migrations:migrate
CRUD & Symfony
Symfony permet aussi de créer facilement un CRUD. Dans chaque Controller, on va pouvoir déclarer toutes les routes correspondant au CRUD, ainsi que les méthodes à utiliser.
Ensuite, on utilisera Twig pour l’affichage de chaque page.
Tout est détaillé dans la doc de Symfony, je vous laisse donc y jeter un œil ! 😉
L’apprentissage de Symfony est un énorme morceau lorsque l’on se plonge dans le Back.
Je vous avouerais que ça n’a pas été ma tasse de thé et je m’excuse d’avance de ne pas avoir détaillé plus tous mes cours…
J’ai enfin fini la formation avec un projet de groupe que je vous laisserai découvrir dans le prochain post ! 🙂
