Le guide du débutant sur Symfony4

Symfony 4 est la version de Symfony qui à soulevé le plus d'engouement auprès de la communauté PHP, sur presque tout, 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.

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 19.625 stars (au moment d'écriture de ce tutoriel) sur Github.

Les bases à avoir pour faire du 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 et n'oubliez jamais cela.

Pour faire du Symfony, il vous faut donc une bonne connaissance de la Programmation Orienté Objet en PHP et aussi des Namespaces.

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).

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. Pour connaître comment il marche, allez lire ce tutoriel.

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 et vous devez aussi le privilégié par rapport à l'installateur Symfony. Entrer donc cette ligne 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.

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

Si tout va bien, vous devez obtenir

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, tout cela est fait avec Symfony flex.

Vous pouvez maintenant essayer la commande server:start de tout à l'heure ou la commande server:run comme ceci:

php bin/console server:run

Normalement ça marche avec maintenant.

Ouvrez donc votre navigateur et naviguer sur l'adresse http://127.0.0.1:8000, votre navigateur doit ressembler à cela

Tout va bien, vous pouvez continuer.

Architecture des dossiers

Si vous venez de Symfony 3, vous voyez tout de suite la différence. 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.
• 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, ...

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.

Petit aperçu de quelques éléments

Avant de commencer à écrire du code, j'aimerais que l'on parle de quelques éléments autour de Symfony, histoire de ne pas se perdre.

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 et plein d'autres. Pour vois 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.

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.

Flex conserve la trace des recettes qu'il a installées dans un fichier symfony.lock (équivalent de composer.lock), qui doit être validé dans notre référentiel de code.

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: le Bonheur quoi.

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.

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

Créer une route

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

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. Je suis un peu fainéant nous allons donc 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

<?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',
        ]);
    }
}

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 sur la ligne 6, puis retourner une réponse tout simplement. 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>');
    }
}

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 doit 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.

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.

L'autre intérêt avec Twig c'est sa rapidité, tous les templates sont compilés en PHP et mise 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 que nous allons afficher à l'utilisateur.

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>

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');
    }
}

Sur la ligne 11, 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

Enregistrons tout ça et allons voir ce que nous avons:

Notre page s'affiche normalement.

Voila, vous savez maintenant comment créer une route, l'associer à un contrôleur et retourner une vue à l'utilisateur, vous saurez donc développer votre prochaine application avec Symfony.

C'est fini pour ce tutoriel, si tu as des questions ou des problèmes, n'hésite pas, rends toi dans la section commentaire ci-dessous et explique nous ton problème.

Tu as aimé ce tutoriel? Partage le avec tes proches dans la section ci-dessous. Sinon dis moi ce que tu n'a pas aimé, j'accepte les critiques :-)