Démarrer avec Symfony4

FAYCEL EL AYEB
Démarrer avec Symfony4

 Symfony 4 est la version de Symfony qui à soulevé le plus d’intéret auprès

de la communauté PHP. La version 4 de Symfony diffère des version
précédentes. Si vous avez déjà fait du Symfony 3, vous saurez de quoi je
parle, sinon, vous allez découvrir un framework aussi élégant
qu’extraordinaire.

 Et comme l’a dit Fabien Potencier, fondateur et chef de projet Symfony :

Simple, no magic, no configuration, great developer experience. You will
love Symfony 4.

 Cette phrase résume tout, Symfony 4 c’est un vrai régal pour les
développeurs PHP.
Qu’est ce que c’est Symfony?

 Sur le site officiel du framework, Symfony se définit comme ceci:

Symfony is a set of PHP Components, a Web Application framework, a

Philosophy, and a Community — all working together in harmony.

 En français cela veut dire:

Symfony est un ensemble de composants PHP, un framework d'application

Web, une philosophie et une communauté - tous travaillant ensemble en
harmonie.
Qu’est ce que c’est Symfony?

 Ensemble de composants PHP : Symfony lui même est un composant PHP

et fonctionne avec d’autres composants PHP comme symfony/yaml,
symfony/twig-bundle, … Ce qui est extraordinaire, c’est que ces
composants peuvent même fonctionner sans Symfony.
 Framework d’application Web :Un framework web est un ensemble
d’outils conçus pour faciliter votre processus de développement
d’application web. L’objectif d’un framework c’est de vous apporter les
composants de bases qui constituent toutes les applications web tel un
système de gestion des routes, un moteur de templates, …
 Une philosophie et une communauté : Symfony c’est une philosophie de
développement d’application, un projet open source avec une
communauté de plus de 1.700 contributeurs et plus que 19.625 stars.
Les bases à avoir pour faire de symfony

 Si c’est votre début avec le framework Symfony, il faut savoir qu’il vous
faut de bases solides en PHP pour pouvoir travailler avec le framework.

 Quand vous travaillez avec un framework, n’importe quel framework, il

faut savoir qu’il est écrit dans un langage de programmation spécifique:
PHP pour Symfony et Laravel, Python pour Django, … Il faut savoir que
vous écrivez donc du code PHP dans le cas de Symfony.

 Pour faire du Symfony, il vous faut donc une bonne connaissance de la

Programmation Orienté Objet en PHP.
Le Modèle MVC
 Symfony est un framework basé sur le modèle MVC (Model View
Controller).
 Pour faire simple, le modèle MVC va nous aider à séparer les requêtes de
la base de données (Model) de la logique relative au traitement des
demandes (Controller) et au rendu de la présentation (View).

 La demande de l’utilisateur
(exemple : requête HTTP) est
reçue et interprétée par le
Contrôleur. Celui-ci utilise les
services du Modèle afin de
préparer les données à afficher.
Ensuite, le Contrôleur fournit ces
données à la Vue, qui les
présente à l’utilisateur (par
exemple sous la forme d’une
page HTML).
Le Composer

 Composer est un outil de gestion de dépendances PHP. Il va nous

permettre de déclarer les librairies dont notre projet dépend et s’occuper
de les gérer (installation/mis à jour) pour nous.

 Quand vous travaillez sur un grand projet PHP, il arrive pour éviter de
recréer la roue et aller plus vite dans le développement de votre
application, d’utiliser des librairies externes comme pour la gestion de vos
utilisateurs ou un système d’envoie de mails, Composer va donc vous
permettre de gérer toutes vos dépendances sans trop se casser la tête.
Installation de Symfony

 Maintenant que vous avez installer composer, et que vous savez ce qu’est
Symfony, nous allons procéder à l’installation du framework Symfony. Dans
ce tutoriel, nous allons utiliser la version LTS (Long Term Support) de
Symfony 4, la version 4.4.
 Pour installer Symfony, nous pouvons soit utiliser composer ou l’installateur
Symfony, nous allons utiliser ici composer. Entrer donc cette ligne de
commande en vous plaçant dans le dossier dans lequel vous voulez créer
votre projet:

$ composer create-project symfony/website-skeleton blog "4.4.*“

 Ceci va créer le dossier blog qui va contenir votre projet et installer toutes
les dépendances de base d’une application web ordinaire comme le
moteur de templates Twig.
Installation de Symfony

 Si vous avez juste besoin de créer une API, vous n’aurez pas besoin de
toutes ces dépendances, Symfony à aussi penser à vous, il suffit de faire:
$ composer create-project symfony/skeleton blog "4.4.*"
 Avec cette installation, vous installez juste les dépendances basiques, pas
besoin de moteur de templates.
 Nous allons utiliser la première avec symfony/website-skeleton parce que
nous créons une application web ordinaire.
 Maintenant que notre projet a été créé, déplacez vous dans le dossier du
projet et lancer le serveur

$ cd blog
$ php bin/console server:start
Installation de Symfony

Si tout va bien, vous devez obtenir:

[OK] Server listening on http://127.0.0.1:8000

Si vous avez une erreur qui vous dit que la commande server:start n'est pas
défini, il faut donc installer un serveur de développement en faisant:

$ composer req server

Nous disons à Symfony que nous avons besoin d'un serveur de

développement, il va donc nous télécharger le package symfony/web-
server-bundle et l'ajouter à nos dépendances.
Installation de Symfony

 Vous pouvez maintenant essayer la commande server:start de tout à

l'heure ou la commande server:run comme ceci:

$ php bin/console server:run

 Ouvrez donc votre navigateur et naviguer sur l’adresse

http://127.0.0.1:8000, votre navigateur doit ressembler à cela:
Installation de Symfony
Architecture des dossiers

 Expliquons un peu comment tout ça est organisé:

 bin: c’est ici que se trouve les exécutables de Symfony, comme le fichier
console. Les fichiers dans ce dossier seront donc exécutables en ligne de
commande.
 config: comme son nom l’indique, ce dossier va contenir la configuration
de notre application Symfony. C’est ici que nous allons configurer les
routes, les services, …
 public: Ceci est le dossier d’entré de notre application, mais aussi le
dossier public, nous allons y mettre tout les fichiers accessibles au public. Il
contient notamment le contrôleur frontal de Symfony.
 src: C’est ici que la magie s’opère, c’est ici que vous écrirez vos fichiers
PHP. Les contrôleurs, entités, migrations, … sont dans ce dossier.
Architecture des dossiers

 templates: Les vues de notre application sont ici, toutes les pages qui vont
être affichées à l'écran vont être ici.
 tests: C’est ici que vous allez mettre les différents tests pour tester vos
fonctionnalités.
 var: Dans ce dossier Symfony va mettre les caches et logs
 vendor: Ce dossier contient toutes les dépendances créées avec
composer.
 .env: Ce fichier définit les variables d’environnement de notre application,
il définit l’environnement dans lequel nous sommes, développement ou
production, les informations de connexion à la BDD, ...
Petit aperçu de quelques éléments:

#Contrôleur Frontal
 Le contrôleur frontal est le fichier d’entré de notre application, toute
requête va passer par ce fichier avant de continuer. Le contrôleur frontal
de Symfony 4 se situe dans public/index.php il réceptionne donc toutes
les requêtes qui arrivent à notre application et renvoie la réponse
adéquate au client.
#php bin/console
 Si vous vous rappelez bien, c'est la commande que nous avons écrite tout
à l'heure pour lancer le serveur. Celui ci représente en quelque sorte la
ligne de commande de Symfony, elle va par exemple nous permettre de
créer nos contrôleurs, créer des entités, des migrations etc. Pour voir
toutes les commandes possible, il suffit de faire:
$ php bin/console
 Nous avons alors la liste de toutes les commandes disponibles, vous
pouvez donc lire la documentation de chaque commande et essayer de
comprendre ce qu'elle fait.
Petit aperçu de quelques éléments:
#Symfony Flex
 Symfony Flex est un moyen d’installer et de gérer des applications Symfony. Il
automatise les tâches les plus courantes des applications Symfony. Il a été lancer
avec la version 4 de Symfony.
 Flex est un plugin composer qui modifie le comportement des commandes
require, update et remove. Par exemple, lorsque nous exécutons la commande
require, l'application adresse une demande au serveur de Symfony Flex avant
d'essayer d'installer le package avec composer. S'il n'y a aucune information sur
le paquet que nous voulons installer, le serveur Flex ne renvoie rien et l'installation
du paquet suit la procédure habituelle basée sur Composer. S'il y a des
informations, Flex les renvoie dans un fichier appelé "recette" (recipes) et
l'application l'utilise pour décider quel package installer et quelles tâches
exécuter automatiquement après l'installation.
 Les recettes sont définies dans un fichier manifest.json et les instructions définies
dans ce fichier sont également utilisées par Flex lors de la désinstallation des
dépendances pour annuler toutes les modifications.
 L'une des forces de Symfony Flex, c'est quand vous installez un package, il
configure automatiquement le package dans le projet, en fonction de ce que
les développeurs du package ont mentionné dans le recipe, et quand vous le
supprimez, ça se passe automatiquement encore, toutes les configurations
relatives au package sont supprimées.
Petit aperçu de quelques éléments:

#Doctrine
 Doctrine est ce qu’on appelle un ORM (Object Relational Mapper), pour
faire simple, il va nous permettre de créer, modifier, supprimer ou
récupérer des objets dans la base de données en utilisant des classes.
#Contrôleur
 L’un des composants de l’acronyme MVC, le contrôleur est une fonction
PHP que nous allons créer et qui va permettre de lire une requête et
renvoyer une réponse, c’est tout son fonctionnement, recevoir une
requête et retourner une réponse.
# Route
 La route représente le lien entre une URL et un contrôleur. Quand le
serveur reçoit une requête HTTP, symfony regarde dans le fichier
config/routes.yaml pour trouver la route, et cette route va définir le
contrôleur a appelé dans ce cas.
Petit aperçu de quelques éléments:

#Requêtes et Réponses
 Symfony fournit une approche à travers deux classes pour interagir avec la
requête et la réponse HTTP. La classe Request est une représentation de la
requête HTTP, tandis que la classe Response est évidemment une représentation
de la réponse HTTP.

 Un moyen de gérer ce qui se passe entre la requête et la réponse consiste à

utiliser un contrôleur frontal (public/index.php). Ce fichier traitera chaque
demande entrant dans notre application. Cela signifie qu'il sera toujours exécuté
et qu'il gérera le routage de différentes URL vers différentes parties de notre
application.

 Dans Symfony, les demandes entrantes sont interprétées par le composant

Routing et transmises aux fonctions PHP (contrôleurs) qui renvoient des réponse.
Cela signifie que le contrôleur frontal transmettra la demande à Symfony. Ce
dernier créera un objet de réponse et le transformera en en-têtes de texte et le
contenu sera finalement renvoyé.
Créer votre page d’accueil

 Pour créer une page avec Symfony, il faut remplir ces deux conditions:
 créer une route
 créer un contrôleur

 Pour créer une route, vous avez besoin de:

 son nom: comme une variable en fait, pas d’espace, remplacer les
espaces par des underscores (_)
 son chemin: le chemin est ce qui va s’afficher dans le navigateur du
client, (/tutorial, /a-propos, /accueil, …) la aussi éviter les espaces, utiliser
plutôt le tiret à la place (-)
 son contrôleur: une méthode PHP qui va traiter la requête de l’utilisateur
et lui renvoyer une réponse
Créer une route

 Rendez-vous dans le fichier config/routes.yaml et mettez-y ce code:

homepage:
path: /
controller: App\Controller\BlogController::index

 Nous créons une route qui s’appelle homepage dont le chemin est / et
qui a comme contrôleur la méthode index qui se trouve dans la classe
BlogController.

 Allons donc créer ce contrôleur et faire le lien avec notre route.

Créer une route

 Rendez-vous dans le fichier config/routes.yaml et mettez-y ce code:

homepage:
path: /
controller: App\Controller\BlogController::index

 Nous créons une route qui s’appelle homepage dont le chemin est / et
qui a comme contrôleur la méthode index qui se trouve dans la classe
BlogController.

 Allons donc créer ce contrôleur et faire le lien avec notre route.

Créer un contrôleur

 Pour créer un contrôleur, nous pouvons soit aller nous même créer la
classe ou passer par la ligne de commande. Nous allons passer par la
ligne de commande.
$ php bin/console make:controller BlogController
 Nous demandons à Symfony de nous créer le contrôleur BlogController,

 C'est clair la je pense, 2 fichiers ont été créés, BlogController.php dans

src/Controller et index.html.twig dans templates/blog, nous allons pas
toucher pour l'instant.

Ouvrons maintenant le fichier src/Controller/BlogController.php

Créer un contrôleur
 Ouvrons maintenant le fichier src/Controller/BlogController.php:
<?php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
class BlogController extends AbstractController
{
/**
* @Route("/blog", name="blog")
*/
public function index() {
return $this->render('blog/index.html.twig', [
'controller_name' => 'BlogController',
]);
}
}
Créer un contrôleur
 Symfony nous a créer le contrôleur, et a même défini une route en utilisant
ce qu’on appelle des annotations.

 En Symfony, nous pouvons définir nos routes soit en utilisant des

annotations, un fichier yaml, un fichier xml ou avec du PHP.
Personnellement je préfère utiliser un fichier yaml pour définir mes routes.
 Nous allons donc supprimer la docstring qui se trouve avant la fonction
index() et aussi effacer le use qui importe les annotations, puis retourner
une réponse tout simplement.
Créer un contrôleur
 Voici le code du fichier BlogController.php à l’instant:
<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;

class BlogController extends AbstractController

{
public function index()
{
return new Response('<h1>Hello World!</h1>');
}
}
Créer un contrôleur
 Nous retournons un objet Response avec du HTML qui affiche Hello World!
 On enregistre et nous pouvons maintenant aller actualiser notre page
dans le navigateur, si tout marche bien, on soit obtenir ce qui se trouve sur
cette image:

 Ici nous retournons une simple réponse avec la classe Response, cette
méthode de faire à ses limites quand on veut retourner une page HTML.
Vous imaginez écrire une page web entière dans du PHP? Impossible.
Retourner une page HTML

 Le moteur de template de Symfony est Twig. Mais pourquoi utiliser un

moteur de templates?

 En temps normal, si nous voulons afficher du code dynamique en PHP,

nous écrivons du PHP entre du code HTML, si vous l’avez déjà fait, vous
devez savoir combien c’est difficile de se retrouver dans un tel code et
surtout combien c'est compliqué de le maintenir.
TWIG
 Pour parcourir un tableau d’objets et l’afficher en PHP on va devoir faire:
<ul>
<?php
foreach($users as $user) { ?>
<li><?php echo $user->getName(); ?></li>
<?php} ?>
</ul>
 Avec Twig ça va donner
<ul>
{% for user in users %}
<li>{{ user.name }}</li>
{% endfor %}
</ul>
 C’est beaucoup plus lisible.
TWIG
 L’autre intérêt avec Twig c’est sa rapidité, tout les templates sont compilés
en PHP et mis en cache, seulement quand vous changez le code d’un
template, Twig le recompile et le met encore en cache, ce qui est très
pratique en production.

 Le dossier templates à la racine contient tous les templates que nous

allons développer pour notre application, si vous regardez, vous devez
voir un dossier blog, ce dossier à été créer lorsque nous avons généré le
contrôleur, à l'intérieur de ce dossier se trouve le fichier index.html.twig.
index.html.twig
 Modifiez donc le fichier index.html.twig comme ceci:
<!DOCTYPE html>
<html>
<head>
<title>Bienvenue sur mon blog</title>
<meta charset="utf-8">
</head>
<body>
<h1>Hello World!</h1>
<h2>Bienvenue sur mon blog!</h2>
</body>
</html>
BlogController.php
 Allons maintenant modifier le contrôleur dans le fichier BlogController.php
<?php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
class BlogController extends AbstractController
{
public function index(){
return $this->render('blog/index.html.twig');
}
}
 Nous utilisons la méthode render() pour retourner la page html, en
paramètre nous l’envoyons le chemin de notre template
blog/index.html.twig.
Résultat

 Voila, vous savez maintenant comment créer une route, l'associer à un

contrôleur et retourner une vue à l'utilisateur.