Cours Configuration Symfony Enasic PDF

Tutoriel Symfony
Symfony est un framework d'applications Web PHP open-source, conçu pour les
développeurs qui ont besoin d'une boîte à outils simple et élégante pour créer des
applications Web complètes.
Symfony est sponsorisé par SensioLabs. Il a été développé par Fabien Potencier en
2005.
Ce tutoriel vous donnera une introduction rapide au framework Symfony et vous

familiarisera avec ses différents composants.
Public
Ce tutoriel a été préparé pour les débutants qui souhaitent apprendre les concepts
fondamentaux du framework Symfony. Les lecteurs comprendront suffisamment
comment créer et développer un site Web à l'aide de Symfony.
Conditions préalables
Avant de passer aux différents types de composants donnés dans ce didacticiel, il est
supposé que les lecteurs sont déjà conscients de ce qu'est un Framework. En plus de
cela, il sera également très utile si vous avez une bonne connaissance des concepts
HTML, PHP.
Symfony - Présentation
Un framework web PHP est un ensemble de classes qui aide à développer une
application web.
Symfony est un framework MVC open-source pour développer rapidement des
applications web modernes.
Symfony est un framework web full-stack. Il contient un ensemble de composants

PHP
réutilisables.
Vous pouvez utiliser n'importe quel composant Symfony dans les applications,
indépendamment du framework.
Symfony a une énorme quantité de fonctionnalités et une communauté active.
Il a une configuration flexible utilisant YAML, XML ou des annotations.
Symfony s'intègre avec une bibliothèque indépendante et une unité PHP.

Symfony s'inspire principalement des frameworks d'applications Web Ruby on Rails,
Django et Spring. Les composants Symfony sont utilisés par de nombreux projets open
source, notamment Composer, Drupal et phpBB.
Le framework Symfony se compose de plusieurs composants, tels que le composant

HttpFoundation qui comprend HTTP et offre un bel objet de requête et de réponse
utilisé par les autres composants. D'autres ne sont que des composants d'assistance,
tels que le validateur, qui aident à valider les données. Le composant noyau est le
cœur du système. Le noyau est essentiellement la "classe principale" qui gère
l'environnement et a la responsabilité de gérer une requête http.
La structure bien organisée de Symfony, son code propre et ses bonnes pratiques de
programmation facilitent le développement Web.
Symfony est très flexible, utilisé pour créer des micro-sites et gérer des applications
d'entreprise avec des milliards de connexions.
Framework Symfony - Fonctionnalités
Symfony est conçu pour optimiser le développement d'applications Web et augmente

ses fonctionnalités à chaque version.
Certaines des principales caractéristiques de Symfony Framework sont les suivantes -
Système basé sur Model-View-Controller

Framework PHP performant
Routage URI flexible
Code réutilisable et plus facile à entretenir
Gestion des sessions
Journalisation des erreurs
Classes de base de données complètes avec prise en charge de plusieurs plates-
formes
Prend en charge une communauté énorme et active
Ensemble de composants découplés et réutilisables
Standardisation et interopérabilité des applications
Sécurité contre la falsification des requêtes intersites et autres attaques
Moteur de modèle Twig
Symfony offre beaucoup de flexibilité aux développeurs.

Il possède d'excellentes fonctionnalités pour le débogage, la lisibilité du code et le
développement de programmes extensibles.
Symfony est un framework Web complet ;
c'est un outil très efficace pour créer des applications web.
De nombreuses entreprises proposent les services Symfony à leurs clients.
Voici quelques-uns des avantages que vous obtenez en utilisant le Framework

Symfony.
Microframework − Symfony peut être utilisé pour développer une fonctionnalité

spécifique.
Vous n'avez pas besoin de redévelopper ou d'installer l'ensemble du framework.
Réduit les frais généraux de temps de développement.
Moteur de template extrêmement mature et fournit rapidement du contenu aux

utilisateurs.
Compatible et extensible − Les programmeurs peuvent facilement étendre toutes

les classes du framework.
Framework Symfony - Applications
Les composants Symfony peuvent être utilisés dans le cadre d'autres applications telles
que Drupal, Laravel, phpBB, Behat, Doctrine et Joomla.
Drupal 8 - Drupal est un framework PHP open source de gestion de contenu.

Drupal 8 utilise les couches principales de Symfony et l'étend pour prendre en
charge les modules Drupal.
Thelia − Thelia est une solution e-commerce basée sur Symfony.

Initialement, Thelia était écrit en code PHP et MySQL, cependant, il tardait à
produire des applications plus rapides.
Pour pallier cet inconvénient, Thelia s'est intégré à Symfony pour développer les
applications de manière personnalisable.
Dailymotion − Dailymotion est l'un des plus grands sites Web indépendants de
divertissement vidéo au monde basé en France.
Une fois qu'ils ont décidé de migrer le framework open source avec une large
communauté, les développeurs de Dailymotion ont décidé d'utiliser les fonctionnalités
des composants Symfony pour sa flexibilité.
Symfony-Installation
Ce chapitre explique comment installer le framework Symfony sur votre machine.

L'installation du framework Symfony est très simple et facile.
Vous avez deux méthodes pour créer des applications dans le framework Symfony. La
première méthode consiste à utiliser Symfony Installer, une application pour créer un
projet dans le framework Symfony.
La deuxième méthode est l'installation basée sur le compositeur.

Passons en revue chacune des méthodes une par une en détail dans les sections
suivantes.
Configuration requise
Avant de passer à l'installation, vous avez besoin de la configuration système

suivante.
Web server (Any one of the following)
• WAMP (Windows)
• LAMP (Linux)
• XAMP (Multi-platform)
• MAMP (Macintosh)
• Nginx (Multi-platform)
• Microsoft IIS (Windows)
• PHP built-in development web server (Multi-platform)
Système d'exploitation : multiplateforme
• Browser Support: IE (Internet Explorer 8+), Firefox, Google Chrome, Safari,

Opera
• PHP Compatibility: PHP 5.4 or later. To get the maximum benefit, use the
latest version.
Nous utiliserons le serveur Web de développement intégré PHP pour ce didacticiel.

Installateur Symfony
Symfony Installer est utilisé pour créer des applications Web dans le framework
Symfony. Maintenant, configurons le programme d'installation de Symfony à l'aide de
la commande suivante.
$ sudo mkdir -p /usr/local/bin

$ sudo curl -LsS https://symfony.com/installer -o /usr/local/bin/symfony
$ sudo chmod a+x /usr/local/bin/symfony
Maintenant, vous avez installé le programme d'installation de Symfony sur votre

machine.
Créez votre première application Symfony
La syntaxe suivante est utilisée pour créer une application Symfony dans la dernière
version.
Syntaxe
symfony new app_name
Ici, app_name est le nouveau nom de votre application. Vous pouvez spécifier le nom
de votre choix.
Exemple
symfony new HelloWorld
Après avoir exécuté la commande ci-dessus, vous verrez la réponse suivante.

Cette commande crée un nouveau répertoire appelé "firstapp/" qui contient un projet
vide de la dernière version du framework Symfony.
Installer une version spécifique
Si vous devez installer une version spécifique de Symfony, utilisez la commande

suivante.
symfony new app_name 2.8

symfony new app_name 3.1
Installation basée sur Composer
Vous pouvez créer des applications Symfony en utilisant Composer. vous devez
installé le compositeur sur votre machine.
Si le compositeur n'est pas installé, téléchargez-le et installez-le.
La commande suivante est utilisée pour créer un projet à l'aide du composeur.
$ composer create-project symfony/framework-standard-edition app_name
Si vous devez spécifier une version spécifique, vous pouvez le spécifier dans la
commande ci-dessus.
Exécution de l'application
Accédez au répertoire du projet et exécutez l'application à l'aide de la commande

suivante.
cd HelloWorld
php bin/console server:run
Après avoir exécuté la commande ci-dessus, ouvrez votre navigateur et demandez l'url
http://localhost:8000/. Il produit le résultat suivant.
Symfony-Architecture
Symfony est essentiellement une collection de composants et de bundles de haute

qualité.
Les composants sont une collection de classes fournissant une fonctionnalité de base
unique.
Par exemple, le composant Cache fournit une fonctionnalité de cache, qui peut être
ajoutée à n'importe quelle application.
Les composants sont des blocs de construction d'une application Symfony.
Symfony a plus de 30 composants de haute qualité, qui sont utilisés dans de
nombreux frameworks PHP tels que Laravel, Silex, etc.
Les bundles sont similaires au plugin mais faciles à créer et à utiliser.
En fait, une application Symfony est elle-même un bundle composé d'autres bundles.
Un seul bundle peut utiliser n'importe quel nombre de composants Symfony ainsi que
des composants tiers pour fournir des fonctionnalités telles que Webframework, l'accès
à la base de données, etc.
Le framework Web principal de Symfony est un bundle appelé FrameworkBundle et il
existe un bundle appelé FrameworkExtraBundle, qui fournit des options plus
sophistiquées pour écrire une application web.
La relation entre les composants, les bundles et l'application Symfony est spécifiée
dans le diagramme suivant.
Framework Web
Symfony est principalement conçu pour écrire des applications Web de haute qualité
avec une relative facilité.
Il fournit diverses options pour écrire différents types d'applications Web, du simple
site Web aux services Web avancés basés sur REST.
Symfony fournit un framework Web sous forme de bundles séparés.
Les bundles communs utilisés dans le framework Web Symfony sont les suivants -
FrameworkBundle
FrameworkExtraBundle
DoctrineBundle
Le framework web Symfony est basé sur l'architecture Model-View-Controller (MVC).

Le modèle représente la structure de nos entités commerciales.
La vue montre les modèles à l'utilisateur de la meilleure façon possible en fonction

de la situation.
Le contrôleur gère toutes les demandes de l'utilisateur, effectue le travail réel en

interagissant avec le modèle et fournit enfin à la vue les données nécessaires pour la
montrer à l'utilisateur.
Le framework Web Symfony fournit toutes les fonctionnalités de haut niveau requises
pour une application de niveau entreprise.
Voici un flux de travail simple de l'application Web Symfony.
Le flux de travail comprend les étapes suivantes.
Étape 1 - L'utilisateur envoie une requête à l'application via le navigateur, par

exemple http://www.symfonyexample.com/index.
Étape 2 - Le navigateur enverra une requête au serveur Web, par exemple le serveur
Web Apache.
Étape 3 - Le serveur Web transmettra la requête au PHP sous-jacent, qui l'enverra à

son tour au framework Web Symfony.
Étape 4 - HttpKernel est le composant principal du framework Web Symfony.

HttpKernel résout le contrôleur de la demande donnée à l'aide du composant de
routage et transmet la demande au contrôleur cible.
Étape 5 - Toute la logique métier se déroule dans le contrôleur cible.
Étape 6 - Le contrôleur interagira avec Model, qui à son tour interagit avec
Datasource via Doctrine ORM.
Étape 7 - Une fois que le contrôleur a terminé le processus, il génère la réponse lui-
même ou via View Engine, et la renvoie au serveur Web.
Étape 8 - Enfin, la réponse sera envoyée au navigateur demandé par le serveur Web.
Symfony – Composants
Comme indiqué précédemment, les composants Symfony sont une bibliothèque PHP
autonome fournissant une fonctionnalité spécifique, qui peut être utilisée dans
n'importe quelle application PHP.
De nouveaux composants utiles sont introduits dans chaque version de Symfony.

Actuellement, il existe plus de 30 composants de haute qualité dans le framework
Symfony.
Découvrons l'utilisation des composants Symfony dans ce chapitre. Installer un

composant Symfony
Les composants Symfony peuvent être installés facilement à l'aide de la commande

composer.
La commande générique suivante peut être utilisée pour installer n'importe quel
composant Symfony.
cd /path/to/project/dir
composer require symfony/<component_name>
Créons une application php simple et essayons d'installer le composant Filesystem.
Étape 1 - Créez un dossier pour l'application, filesystem-example
cd /path/to/dev/folder
mdkir filesystem-example
cd filesystem-example
Étape 2 - Installez le composant Filesystem à l'aide de la commande suivante.
composer require symfony/filesystem
Étape 3 - Créez un fichier main.php et entrez le code suivant.
<?php
require_once __DIR__ . '/vendor/autoload.php';
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
$fs = new Filesystem();

try {
$fs->mkdir('./sample-dir');
$fs->touch('./sample-dir/text.txt');
} catch (IOExceptionInterface $e) {
echo $e;
}
?>
La première ligne est très importante, elle charge toutes les classes nécessaires de
tous les composants installés à l'aide de la commande Composer.
Les lignes suivantes utilisent la classe Filesystem.
Étape 4 - Exécutez l'application à l'aide de la commande suivante et elle créera un

nouveau dossier sample-dir et un fichier test.txt en dessous.
php main.php
Détails des composants Symfony
Symfony fournit des composants allant de la fonctionnalité simple, par exemple le

système de fichiers, à la fonctionnalité avancée, par exemple les événements, la
technologie des conteneurs et l'injection de dépendances.
Faites-nous connaître tous les composants un par un dans les sections suivantes.
Système de fichiers
Le composant de système de fichiers fournit une commande système de base liée aux
fichiers et aux répertoires tels que la création de fichiers, la création de dossiers,
l'existence de fichiers, etc.
Le composant de système de fichiers peut être installé à l'aide de la commande
suivante.
Finder
Le composant Finder fournit des classes fluides pour rechercher des fichiers et des
répertoires dans un chemin spécifié. Il fournit un moyen facile d'itérer sur les fichiers
d'un chemin. Le composant Finder peut être installé à l'aide de la commande
suivante.
Console
Le composant Console fournit diverses options pour créer facilement des commandes
pouvant être exécutées dans un terminal.
Symfony utilise largement le composant Command pour fournir diverses
fonctionnalités telles que la création d'une nouvelle application, la création d'un
bundle, etc.
Même le serveur Web PHP intégré peut être appelé à l'aide de la commande
Symfony, php bin/console server:run comme indiqué dans la section d'installation.
Le composant Console peut être installé à l'aide de la commande suivante.
composer require symfony/console
Créons une application simple et créons une commande, HelloCommand en utilisant

le composant Console et invoquons-le.
Étape 1 - Créez un projet à l'aide de la commande suivante.

cd /path/to/project
composer require symfony/console
Étape 2 - Créez un fichier main.php et incluez le code suivant.
<?php
require __DIR__ . '/vendor/autoload.php';

use Symfony\Component\Console\Application;
$app = new Application();

$app->run();
?>
La classe d'application configure les fonctionnalités nécessaires d'une application de console simple.
Étape 3 - Exécutez l'application, php main.php, qui produira le résultat suivant.
Console Tool
Usage:
command [options] [arguments]
Options:
-h, --help Display this help message
-q, --quiet Do not output any message
-V, --version Display this application version
--ansi Force ANSI output
--no-ansi Disable ANSI output
-n, --no-interaction Do not ask any interactive question
-v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output,
2 for more verbose output and 3 for debug
Available commands:
help Displays help for a command
list Lists commands
Étape 4 - Créez une classe appelée HelloCommand étendant la classe Command dans
le main.php lui-même.
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputArgument;
class HelloCommand extends Command {

}
L'application utilise les quatre classes suivantes disponibles dans le composant
Command.
Commande - Utilisé pour créer une nouvelle commande
InputInterface - Utilisé pour définir les entrées utilisateur
InputArgument - Utilisé pour obtenir les entrées de l'utilisateur
OutputInterface - Utilisé pour imprimer la sortie sur la console
étape 5 - Créez une fonction configure() et définissez le nom, la description et le

texte d'aide.
protected function configure() {

$this
->setName('app:hello')
->setDescription('Sample command, hello')
->setHelp('This command is a sample command')
}
step 6 − Créez un argument d'entrée, un utilisateur pour la commande et définissez-

le comme obligatoire.

$this
->addArgument('name', InputArgument::REQUIRED, 'name of the user');
}
étape 7 - Créez une fonction execute() avec deux arguments InputArgument et

OutputArgument.
protected function execute(InputInterface $input, OutputInterface $output) {

}
étape 8 - Utilisez InputArgument pour obtenir les détails de l'utilisateur saisis par
l'utilisateur et imprimez-les sur la console à l'aide de OutputArgument.

$name = $input->getArgument('name');
$output->writeln('Hello, ' . $name);
}
étape 9 - Enregistrez la HelloCommand dans l'application à l'aide de la méthode add
de la classe Application.
$app->add(new HelloCommand());
L'application complète est la suivante.
<?php
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputArgument;
class HelloCommand extends Command {

$this
->addArgument('name', InputArgument::REQUIRED, 'name of the user');
}
$name = $input->getArgument('name');
$output->writeln('Hello, ' . $name);
}
$app = new Application();
$app->add(new HelloCommand());
$app->run();
}
?>
Étape 10 - Maintenant, exécutez l'application en utilisant la commande suivante et le

résultat sera Hello, Jon comme prévu.
php main.php app:hello Jon
Symfony est livré avec un binaire pré-construit appelé console dans le répertoire bin
de n'importe quelle application Web Symfony, qui peut être utilisé pour invoquer les
commandes dans une application.
Processus
Le composant de processus fournit des options pour exécuter n'importe quelle

commande système dans un sous-processus, de manière sûre et efficace.
Le composant de processus peut être installé à l'aide de la commande suivante.
composer require symfony/process
Chargeur de classe (ClassLoader)
Le composant ClassLoader fournit une implémentation pour les normes de chargeur

de classe PSR-0 et PSR-4.
Il peut être utilisé pour charger automatiquement les classes.
Il sera amorti dans un proche avenir.
Le chargeur de classe basé sur Composer est préféré à ce composant.
Le composant ClassLoader peut être installé à l'aide de la commande suivante.
composer require symfony/class-loader
PropertyAccess
Le composant PropertyAccess fournit diverses options pour lire et écrire les détails d'un objet et d'un
tableau à l'aide de la notation de chaîne(string).
Par exemple, un tableau Product avec la clé price est accessible dynamiquement à l'aide de la chaîne
[price]([price] string).
$product = array(
'name' => 'Cake'
'price' => 10
);
var priceObj = $propertyAccesserObj->getValue($product, '[price]');
Le composant PropertyAccess peut être installé à l'aide de la commande suivante.
composer require symfony/property-access
InfoPropriété(PropertyInfo)
Le composant PropertyInfo est similaire au composant PropertyAccess, mais il ne

fonctionne qu'avec des objets PHP et offre beaucoup plus de fonctionnalités.
class Product {
private $name = 'Cake';
private $price = 10;
public function getName() {

return $this->name;
}
public function getPrice() {
return $this->price;
}
}
$class = Product::class;
$properties = $propertyInfoObj->getProperties($class);
/*
Example Result
--------------
array(2) {
[0] => string(4) "name"
[1] => string(5) "price"
}
*/
Le composant PropertyInfo peut être installé à l'aide de la commande suivante.
composer require symfony/property-info
Répartiteur d'événements(EventDispatcher)
Le composant EventDispatcher fournit une programmation événementielle en PHP.

Il permet aux objets de communiquer entre eux en envoyant des événements et en
les écoutant.
Nous apprendrons comment créer des événements et les écouter dans le chapitre
Événements et Event Listener.
Le composant EventDispatcher peut être installé à l'aide de la commande suivante.
composer require symfony/event-dispatcher
DépendanceInjection(DependencyInjection)
Le composant DependencyInjection fournit un mécanisme simple et efficace pour créer

un objet avec sa dépendance.
Lorsqu'un projet grandit, il comporte de nombreuses classes avec une dépendance
profonde, qui doivent être gérées correctement.
Sinon, le projet échoue.
DependencyInjection fournit un conteneur simple et robuste pour gérer la

dépendance.
Nous découvrirons les conteneurs et le concept d'injection de dépendances dans le
chapitre Service Container.
Le composant DependencyInjection peut être installé à l'aide de la commande

suivante.
composer require symfony/dependency-injection
Sérialiseur(Serializer)
Le composant Serializer fournit une option pour convertir un objet PHP dans un
format spécifique tel que XML, JSON, Binary, etc., puis lui permet de le reconvertir
en un objet original sans aucune perte de données.
Le composant Serializer peut être installé à l'aide de la commande suivante.
composer require symfony/serializer
Configuration
Le composant Config fournit des options pour charger, analyser, lire et valider les
configurations de type XML, YAML, PHP et ini.
Il fournit également diverses options pour charger les détails de configuration à partir
de la base de données.
C'est l'un des composants importants utiles pour configurer l'application Web de
manière claire et concise.
Le composant de configuration peut être installé à l'aide de la commande suivante.
composer require symfony/config

Langage d'expression(ExpressionLanguage)
Le composant ExpessionLanguage fournit un moteur d'expression à part entière.

Les expressions sont une ligne destinée à renvoyer une valeur.
Le moteur d'expression permet de compiler, d'analyser et d'obtenir facilement la

valeur d'une expression.
Il permet à une ou plusieurs expressions d'être utilisées dans un environnement de
configuration (fichier) par un programmeur non-PHP, par exemple un administrateur
système.
Le composant ExpressionLanguage peut être installé à l'aide de la commande
suivante.
composer require symfony/expression-language
OptionsRésolveur(OptionsResolver)
Le composant OptionsResolver fournit un moyen de valider le système d'options

utilisé dans notre système.
Par exemple, le paramètre de base de données est placé dans un tableau, dboption
avec hôte, nom d'utilisateur, mot de passe, etc., en tant que clés.
Vous devez valider les entrées avant de l'utiliser pour vous connecter à la base de
données.
OptionsResolver simplifie cette tâche en fournissant une simple classe OptionsResolver

et un résolveur de méthode, qui résout le paramètre de base de données et s'il y a
un problème de validation, il le signalera.
$options = array(
'host' => '<db_host>',
'username' => '<db_user>',
'password' => '<db_password>',
);
$resolver = new OptionsResolver();
$resolver->setDefaults(array(
'host' => '<default_db_host>',
'username' => '<default_db_user>',
'password' => '<default_db_password>',
));
$resolved_options = $resolver→resolve($options);
Le composant OptionsResolver peut être installé à l'aide de la commande suivante.
composer require symfony/options-resolver
Dotenv
Le composant Dotenv fournit diverses options pour analyser les fichiers .env et la
variable définie dans ceux-ci pour être accessible via getenv(), $_ENV ou $_SERVER.
Le composant Dotenv peut être installé à l'aide de la commande suivante.
composer require symfony/dotenv
Cache
Le composant Cache fournit une implémentation PSR-6 étendue.
Il peut être utilisé pour ajouter une fonctionnalité de cache à notre application
Web. Puisqu'il suit PSR-6, il est facile de démarrer et il peut être facilement utilisé à
la place d'un autre composant de cache basé sur PSR-6.
Le composant de cache peut être installé à l'aide de la commande suivante.

composer require symfony/cache
International(Intl)
Le composant Intl est la bibliothèque de remplacement pour l'extension C Intl.
Le composant Intl peut être installé à l'aide de la commande suivante.
composer require symfony/intl

Traduction
Le composant de traduction fournit diverses options pour internationaliser notre

application.
Normalement, les détails de traduction des différentes langues seront stockés dans
un fichier, un fichier par langue, et il sera chargé dynamiquement pendant
l'exécution de l'application.
Il existe différents formats pour écrire un fichier de traduction.
Le composant de traduction fournit diverses options pour charger tout type de

format, tel qu'un fichier PHP simple, CSV, ini, Json, Yaml, fichier de ressources ICU,
etc.
Le composant de traduction peut être installé à l'aide de la commande suivante.
composer require symfony/translation
Flux de travail(Workflow)
Le composant Workflow fournit des outils avancés pour traiter une machine à états
finis.
En fournissant cette fonctionnalité de manière simple et orientée objet, le

composant Workflow permet une programmation avancée en PHP avec une relative
facilité.
Nous en apprendrons plus en détail dans le chapitre Concept avancé.
Le composant de workflow peut être installé à l'aide de la commande suivante.
composer require symfony/workflow

Yaml
Le composant Yaml fournit une option qui analyse le format de fichier YAML et le
convertit en tableaux PHP. Il est également capable d'écrire un fichier YAML à partir
d'un tableau php simple. Le composant Yaml peut être installé à l'aide de la
commande suivante.
composer require symfony/yaml
LDAP
Le composant LDAP fournit des classes PHP pour se connecter à un serveur LDAP ou
Active Directory et authentifier l'utilisateur par rapport à celui-ci.
Il fournit une option pour se connecter à un contrôleur de domaine Windows. Le

composant LDAP peut être installé à l'aide de la commande suivante.
composer require symfony/ldap
Déboguer
Le composant de débogage fournit diverses options pour activer le débogage dans

l'environnement PHP.
Normalement, le débogage du code PHP est difficile, mais le composant de débogage

fournit des classes simples pour faciliter le processus de débogage et le rendre propre
et structuré.
Le composant de débogage peut être installé à l'aide de la commande suivante.
composer require symfony/debug

Chronomètre(Stopwatch)
Le composant Stopwatch fournit la classe Stopwatch pour profiler notre code PHP.
Une utilisation simple est la suivante.

use Symfony\Component\Stopwatch\Stopwatch;
$stopwatch = new Stopwatch();
$stopwatch->start('somename');
// our code to profile

$profiled_data = $stopwatch->stop('somename');
echo $profiled_data->getPeriods()
Le composant Chronomètre peut être installé à l'aide de la commande suivante.

composer require symfony/stopwatch
VarDumper
Le composant VarDumper fournit une meilleure fonction dump().
Incluez simplement le composant VarDumper et utilisez la fonction de vidage pour

obtenir la fonctionnalité améliorée.
Le composant VarDumper peut être installé à l'aide de la commande suivante.

composer require symfony/var-dumper
Kit de navigateur
Le composant BrowserKit fournit une interface client de navigateur abstraite.
Il peut être utilisé pour tester l'application Web par programmation.
Par exemple, il peut demander un formulaire, entrer les exemples de données et les
soumettre pour trouver tout problème dans le formulaire par programmation.
Le composant BrowserKit peut être installé à l'aide de la commande suivante.

composer require symfony/browser-kit
Pont PHPUnit(PHPUnit Bridge)
Le composant PHPUnit Bridge fournit de nombreuses options pour améliorer

l'environnement de test PHPUnit. Le composant PHPUnit Bridge peut être installé à
l'aide de la commande suivante.
composer require symfony/phpunit-bridge
Actif(Asset)
Le composant Asset fournit une gestion générique des actifs dans une application
Web.
Il génère des URL pour les actifs tels que CSS, HTML, JavaScript et effectue
également la maintenance des versions.
Nous vérifierons le composant d'actif en détail dans le chapitre Afficher le moteur.
Le composant Asset peut être installé à l'aide de la commande suivante.
composer require symfony/asset
CssSelector
Le composant CssSelector fournit une option pour convertir les sélecteurs basés sur
CSS en expression XPath.
Un développeur Web connaît mieux l'expression des sélecteurs basés sur CSS que
l'expression XPath, mais l'expression la plus efficace pour trouver un élément dans un
document HTML et XML est l'expression XPath.
CssSelector permet au développeur d'écrire l'expression dans les sélecteurs CSS,

cependant, le composant la convertit en expression XPath avant de l'exécuter.
Ainsi, le développeur bénéficie de la simplicité des sélecteurs CSS et de l'efficacité

de l'expression XPath.
Le composant CssSelector peut être installé à l'aide de la commande suivante.

composer require symfony/css-selector
DomCrawler
Le composant DomCrawler fournit diverses options pour trouver l'élément dans un

document HTML et XML à l'aide du concept DOM.
Il offre également la possibilité d'utiliser l'expression XPath pour rechercher un

élément.
Le composant DomCrawler peut être utilisé avec le composant CssSelector pour

utiliser des sélecteurs CSS au lieu de l'expression XPath.
Le composant DomCrawler peut être installé à l'aide de la commande suivante.
composer require symfony/dom-crawler
Form
Le composant de formulaire permet de créer facilement un formulaire dans une
application Web. Nous apprendrons la programmation de formulaires en détail dans
le chapitre Formulaire.
Le composant de formulaire peut être installé à l'aide de la commande suivante.

composer require symfony/form
composer require symfony/http-foundation
HttpKernel
Le composant HttpKernel est le composant central de la configuration Web de

Symfony.
Il fournit toutes les fonctionnalités requises pour une application Web - de la

réception de l'objet Request au renvoi de l'objet Response.
L'architecture complète de l'application Web Symfony est fournie par HttpKernel

comme indiqué dans l'architecture d'un framework Web Symfony.
Le composant HttpKernel peut être installé à l'aide de la commande suivante.

composer require symfony/http-kernel
Routage(Routing)
Le composant de routage mappe la requête HTTP à un ensemble prédéfini de

variables de configuration.
Le routage décide quelle partie de notre application doit gérer une requête.
Nous en apprendrons plus sur le routage dans le chapitre Routage.
Le composant de routage peut être installé à l'aide de la commande suivante.

Modèles(Templating)
Le composant de modèles fournit l'infrastructure nécessaire pour créer un système de

modèles efficace.
Symfony utilise le composant Templating pour son implémentation du moteur View.
Nous en apprendrons plus sur le composant Templating dans le chapitre sur le

moteur de vue.
Le composant de modèle peut être installé à l'aide de la commande suivante.

composer require symfony/templating
Validateur(Validator)
Le composant Validator fournit une implémentation de la spécification de validation
de bean JSR-303.
Il peut être utilisé pour valider un formulaire dans un environnement Web. Nous en
apprendrons plus sur Validator dans le chapitre Validation.
Le composant Validator peut être installé à l'aide de la commande suivante.

composer require symfony/validator
Sécurité
Le composant de sécurité fournit un système de sécurité complet pour notre

application Web, qu'il s'agisse d'une authentification de base HTTP, d'une
authentification par résumé HTTP, d'une authentification basée sur un formulaire
interactif, d'une connexion de certification X.509, etc.
Il fournit également un mécanisme d'autorisation basé sur le rôle de l'utilisateur via
un système ACL intégré.
Nous en apprendrons plus en détail dans le chapitre Concept avancé.
Le composant de sécurité peut être installé à l'aide de la commande suivante.
composer require symfony/security
Symfony - Conteneur de services
Dans toute application, les objets ont tendance à augmenter à mesure que
l'application grandit.
À mesure que les objets augmentent, la dépendance entre les objets augmente
également.
La dépendance d'objet doit être gérée correctement pour une application réussie.
Comme discuté dans le chapitre Composants, Symfony fournit un composant simple et

efficace, DependencyInjection pour gérer les dépendances d'objets.
Un conteneur de service est un conteneur d'objets avec une dépendance

correctement résolue entre eux.
Apprenons à utiliser le composant DependencyInjection dans ce chapitre.
Créons une classe Greeter.
Le but de la classe Greeter est de saluer l'utilisateur comme illustré dans l'exemple
suivant.
$greeter = new Greeter('Hi');

$greeter->greet('Jon'); // print "Hi, Jon"
Le code complet de la classe Greeter est le suivant.
class Greeter {
private $greetingText;
public function __construct($greetingText) {

$this->greetingText = $greetingText;
}
public function greet($name) {
echo $this->greetingText . ", " . $name . "\r\n";
}
}
Maintenant, ajoutons la classe Greeter au conteneur de service.
Symfony fournit ContainerBuilder pour créer un nouveau conteneur.
Une fois le conteneur créé, la classe Greeter peut y être enregistrée à l'aide de la
méthode register du conteneur.
use Symfony\Component\DependencyInjection\ContainerBuilder;
$container = new ContainerBuilder();
$container
->register('greeter', 'Greeter')
->addArgument('Hi');
Ici, nous avons utilisé un argument statique pour spécifier le texte de salutation,
Salut.
Symfony fournit également un réglage dynamique des paramètres.
Pour utiliser un paramètre dynamique, nous devons choisir un nom et le spécifier

entre % et le paramètre peut être défini à l'aide de la méthode setParameter du
conteneur.

$container
->addArgument('%greeter.text%');
$container->setParameter('greeter.text', 'Hi');
Nous avons enregistré une classe Greeter avec un réglage approprié.
Maintenant, nous pouvons demander au conteneur de fournir un objet Greeter

correctement configuré en utilisant la méthode get du conteneur.
$greeter = $container->get('greeter');
$greeter->greet('Jon'); // prints "Hi, Jon"
Nous avons enregistré avec succès une classe, Greeter dans le conteneur, l'avons
extraite du conteneur et l'avons utilisée.
Maintenant, créons une autre classe User, qui utilise la classe Greeter et voyons
comment l'enregistrer.
class User {
private $greeter;
public $name;
public $age;
public function setGreeter(\Greeter $greeter) {

$this->greeter = $greeter;
}
public function greet() {
$this->greeter->greet($this->name);
}
}
La classe User obtient la classe Greeter en utilisant l'une de ses méthodes setter,
setGreeter.
Pour ce scénario, Symfony fournit une méthode, addMethodCall et une classe,

Reference pour référencer une autre classe comme indiqué dans le code suivant.
use Symfony\Component\DependencyInjection\Reference;
$container
->register('user', 'User')
->addMethodCall('setGreeter', array(new Reference('greeter')));
Enfin, nous avons enregistré deux classes, Greeter et User ayant une relation forte
entre elles.
Maintenant, nous pouvons récupérer en toute sécurité l'objet User avec la classe
Greeter correctement configurée à partir du conteneur, comme indiqué dans le code
suivant.
$user = $container->get('user');
$user->name = "Jon";
$user->age = 20;
$user->greet(); // Prints "Hi, Jon"
Nous avons vu comment configurer un objet dans un conteneur en utilisant PHP lui-
même.
Symfony fournit également d'autres mécanismes. Ce sont des fichiers de

configuration XML et YAML.
Voyons comment configurer un conteneur à l'aide de YAML.
Pour cela, installez les composants symfony/config et symfony/yaml avec les

composants symfony/dependency-injection.
cd /path/to/dir
mkdir dependency-injection-example
cd dependency-injection-example
composer require symfony/dependency-injection
composer require symfony/config
composer require symfony/yaml
La configuration YAML sera écrite dans un fichier séparé, services.yml.
La configuration YAML se compose de deux sections, paramètres et
prestations de service.
La section Paramètres définit tous les paramètres requis.

La section Services définit tous les objets.
La section Services est divisée en plusieurs sections, à savoir la classe, les

arguments et les appels.
Classe spécifie la classe réelle.
Arguments spécifie les arguments du constructeur.
Enfin, les appels spécifient les méthodes de définition. Une autre classe peut être
référencée en utilisant le symbole @,
@greeter.
parameters:
greeter.text: 'Hello'
services:
greeter:
class: Greeter
arguments: ['%greeter.text%']
user:
class: User
calls:
- [setGreeter, ['@greeter']]
Désormais, services.yml peut être chargé et configuré à l'aide de FileLoader et

YamlFileLoader, comme indiqué dans le code suivant.
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
$yamlContainer = new ContainerBuilder();

$loader = new YamlFileLoader($yamlContainer, new FileLocator(__DIR__));
$loader->load('services.yml');
$yamlUser = $yamlContainer->get('user');
$yamlUser->name = "Jon";
$yamlUser->age = 25;
$yamlUser->greet();
La liste complète des codes est la suivante.

main.php
<?php
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
class Greeter {
private $greetingText;
public function __construct($greetingText) {

$this->greetingText = $greetingText;
}
public function greet($name) {
echo $this->greetingText . ", " . $name . "\r\n";
}
}
class User {
private $greeter;
public $name;
public $age;
public function setGreeter(\Greeter $greeter) {

$this->greeter = $greeter;
}
public function greet() {
$this->greeter->greet($this->name);
}
}
$container
->addArgument('%greeter.text%');
$container
->register('user', 'User')
->addMethodCall('setGreeter', array(new Reference('greeter')));
$greeter = $container->get('greeter');
$greeter->greet('Jon');
$user = $container->get('user');
$user->age = 20;
$user->greet();
$yamlContainer = new ContainerBuilder();

$loader = new YamlFileLoader($yamlContainer, new FileLocator(__DIR__));
$loader->load('services.yml');
$yamlHello = $yamlContainer->get('greeter');
$yamlHello->greet('Jon');
$yamlUser = $yamlContainer->get('user');
$yamlUser->name = "Jon";
$yamlUser->age = 25;
$yamlUser->greet();
?>
services.yml
parameters:
greeter.text: 'Hello'
services:
greeter:
class: Greeter
arguments: ['%greeter.text%']
user:
class: User
calls:
- [setGreeter, ['@greeter']]
Le framework Web Symfony utilise largement le composant d'injection de

dépendances.
Tous les composants sont liés par le conteneur de service centralisé.
Le framework Web Symfony expose le conteneur dans tous ses contrôleurs via la
propriété conteneur.
Nous pouvons y faire enregistrer tous les objets, par exemple logger, mailer, etc.
$logger = $this->container->get('logger');
$logger->info('Hi');
Pour trouver l'objet enregistré dans le conteneur, utilisez la commande suivante.

cd /path/to/app
php bin/console debug:container
Symfony - Événements et EventListener
Symfony fournit une programmation basée sur les événements via son composant
EventDispatcher.
Toute application d'entreprise a besoin d'une programmation basée sur les événements
pour créer une application hautement personnalisable.
Les événements sont l'un des principaux outils permettant aux objets d'interagir les
uns avec les autres.
Sans événements, un objet n'interagit pas efficacement.
Le processus de programmation basée sur les événements peut être résumé comme
suit : - Un objet, appelé source d'événement, demande à l'objet répartiteur central
d'enregistrer un événement, par exemple user.registered.
Un ou plusieurs objets, appelés listener, demandent à l'objet répartiteur central qu'il

souhaite écouter un événement spécifique, par exemple user.registered.
À un moment donné, l'objet source Event demande à l'objet répartiteur central de

distribuer l'événement, par exemple user.registered avec un objet Event contenant les
informations nécessaires.
Le répartiteur central informe tous les objets d'écoute de l'événement, par exemple
user.registered et son objet Event*.
Dans la programmation basée sur les événements, nous avons quatre types d'objets :
la source d'événement, l'écouteur d'événement, le répartiteur pair et l'événement lui-
même.
Écrivons une application simple pour comprendre le concept.
Étape 1 - Créez un projet, event-dispatcher-example.

cd /path/to/dir
mkdir event-dispatcher-example
cd event-dispatcher-example
composer require symfony/event-dispatcher
Étape 2 - Créez une classe, .User.
class User {
public $name;
public $age;
}
$user = new User();

$user->age = 25
Étape 3 - Créez un événement, UserRegisteredEvent.
use Symfony\Component\EventDispatcher\Event;
class UserRegisteredEvent extends Event {
const NAME = 'user.registered';
protected $user;
public function __construct(User $user) {

$this-<user = $user;
}
public function getUser() {
return $this-<user;
}
}
$event = new UserRegisteredEvent($user);
Ici, UserRegisteredEvent a accès à l'objet User. Le nom de l'événement est

user.registered.
Étape 4 - Créez un écouteur, UserListener.

class UserListener {
public function onUserRegistrationAction(Event $event) {
$user = $event->getUser();
echo $user->name . "\r\n";
echo $user->age . "\r\n";
}
}
$listener = new UserListener();
Étape 5 - Créez un objet répartiteur d'événements.

use Symfony\Component\EventDispatcher\EventDispatcher;
$dispatcher = new EventDispatcher();
Étape 6 - Connectez l'écouteur et l'événement à l'aide de l'objet répartiteur et de sa

méthode, addListener.
$dispatcher
->addListener(
UserRegisteredEvent::NAME,
array($listener, 'onUserRegistrationAction'));
Nous pouvons également ajouter une fonction anonyme en tant qu'écouteur

d'événement, comme indiqué dans le code suivant.
$dispatcher
->addListener(
function(Event $event) {
});
Étape 7 - Enfin, déclenchez/distribuez l'événement à l'aide de la méthode du

répartiteur d'événements, dispatch.
$dispatcher->dispatch(UserRegisteredEvent::NAME, $event);
La liste complète des codes est la suivante.
main.php
<?php
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\Event;
class User {
public $name;
public $age;
}
class UserRegisteredEvent extends Event {
const NAME = 'user.registered';
protected $user;
public function __construct(User $user) {

$this->user = $user;
}
public function getUser() {
return $this->user;
}
}
class UserListener {
public function onUserRegistrationAction(Event $event) {
echo $user->age . "\r\n";
}
}
$user = new User();
$user->age = 25;
$event = new UserRegisteredEvent($user);

$listener = new UserListener();
$dispatcher = new EventDispatcher();

$dispatcher
->addListener(
function(Event $event) {
});
$dispatcher
->addListener(
UserRegisteredEvent::NAME, array($listener, 'onUserRegistrationAction'));
$dispatcher->dispatch(UserRegisteredEvent::NAME, $event);
?>
Résultat
Jon
Jon
25
Le framework Web Symfony a beaucoup d'événements et on peut enregistrer un

écouteur pour ces événements et le programmer en conséquence.
L'un des exemples d'événement est kernel.exception et l'événement correspondant

est GetResponseForExceptionEvent, qui contient l'objet de réponse (la sortie d'une
requête Web). Ceci est utilisé pour intercepter l'exception et modifier la réponse avec
des informations d'erreur génériques au lieu de montrer l'erreur d'exécution aux
utilisateurs.
Symfony-Expression
Comme nous l'avons vu précédemment, le langage d'expression est l'une des

principales caractéristiques de l'application Symfony.
L'expression Symfony est principalement créée pour être utilisée dans un

environnement de configuration.
Il permet à un non-programmeur de configurer l'application Web avec peu d'effort.
Créons une application simple pour tester une expression.
Étape 1 - Créez un projet, expression-language-example.

cd /path/to/dir
mkdir expression-language-example
cd expression-language-example
composer require symfony/expression-language
Étape 2 - Créez un objet d'expression.
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
$language = new ExpressionLanguage();
Étape 3 - Testez une expression simple.
echo "Evaluated Value: " . $language->evaluate('10 + 12') . "\r\n" ;

echo "Compiled Code: " . $language->compile('130 % 34') . "\r\n" ;
Étape 4 - L'expression Symfony est puissante,de sorte qu'elle peut intercepter un objet PHP et sa
propriété également dans le langage d'expression.
class Product {
public $name;
public $price;
}
$product = new Product();
$product->name = 'Cake';
$product->price = 10;
echo "Product price is " . $language

->evaluate('product.price', array('product' => $product,)) . "\r\n";
echo "Is Product price higher than 5: " . $language
->evaluate('product.price > 5', array('product' => $product,)) . "\r\n";
Ici, les expressions product.price et product.price > 5 interceptent le prix de la propriété de l'objet
$product et évaluent le résultat.
Le codage complet est le suivant.
main.php
<?php
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
$language = new ExpressionLanguage();
echo "Evaluated Value: " . $language->evaluate('10 + 12') . "\r\n" ;

echo "Compiled Code: " . $language->compile('130 % 34') . "\r\n" ;
class Product {
public $name;
public $price;
}
$product = new Product();
$product->name = 'Cake';
$product->price = 10;
echo "Product price is " . $language

->evaluate('product.price', array('product' => $product,)) . "\r\n";
echo "Is Product price higher than 5: " . $language
->evaluate('product.price > 5', array('product' => $product,)) . "\r\n";
?>
Résultat
Evaluated Value: 22
Compiled Code: (130 % 34)
Product price is 10
Is Product price higher than 5: 1
Symfony - Offres groupées
Un bundle Symfony est une collection de fichiers et de dossiers organisés dans une structure
spécifique.
Les bundles sont modélisés de manière à pouvoir être réutilisés dans de multiples applications.
L'application principale elle-même est conditionnée sous forme de bundle et est généralement appelée
AppBundle.
Un bundle peut être packagé spécifiquement pour une application telle que AdminBundle (section
admin), BlogBundle (blog du site), etc.
Ces bundles ne peuvent pas être partagés entre une application.
Au lieu de cela, nous pouvons modéliser une certaine partie de l'application, telle que les blogs, en
tant que bundle générique afin que nous puissions simplement copier le bundle d'une application à une
autre application pour réutiliser la fonctionnalité de blog.
Structure d'un bundle
La structure de base d'un bundle est la suivante.
Contrôleur - Tous les contrôleurs doivent être placés ici.
DependencyInjection - Tout le code et la configuration liés à l'injection de dépendances doivent

être placés ici.
Resources/config - Les configurations liées au bundle sont placées ici.
Ressources/vue − Les modèles de vue liés au bundle sont placés ici.
Ressources/public − Les feuilles de style liées au bundle, les JavaScripts, les images, etc., sont
placés ici.
Tests - Les fichiers de tests unitaires liés au bundle sont placés ici.
Création d'un Bundle
Créons un ensemble simple, TutorialspointDemoBundle dans notre application HelloWorld.
Étape 1 - Choisissez un espace de noms. L'espace de noms d'un bundle doit inclure le nom du
fournisseur et le nom du bundle. Dans notre cas, il s'agit de Tutorialspoint\DemoBundle.
Étape 2 - Créez une classe vide, TutorialspointDemoBundle en étendant la classe Bundle et placez-la
sous src/Tutorialspoint/DemoBundle.
namespace Tutorialspoint\DemoBundle;
use Symfony\Component\HttpKernel\Bundle\Bundle;
class TutorialspointDemoBundle extends Bundle {

}
Étape 3 - Enregistrez la classe dans la liste des bundles pris en charge par l'application dans la classe
AppKernel.
public function registerBundles() {

$bundles = array(
// ...
// register your bundle
new Tutorialspoint\DemoBundle\TutorialspointDemoBundle(),
);
return $bundles;
}
C'est tout ce qui est nécessaire pour créer un bundle vide et tous les autres concepts sont les mêmes
que ceux de l'application.
Symfony fournit également une commande console generate:bundle pour simplifier le processus de
création d'un nouveau bundle, qui est le suivant.
php bin/console generate:bundle --namespace = Tutorialspoint/DemoBundle

Résultat
Welcome to the Symfony bundle generator!
Are you planning on sharing this bundle across multiple applications? [no]: no
Your application code must be written in bundles. This command helps

you generate them easily.
Give your bundle a descriptive name, like BlogBundle.

Bundle name [Tutorialspoint/DemoBundle]:
In your code, a bundle is often referenced by its name. It can be the

concatenation of all namespace parts but it's really up to you to come
up with a unique name (a good practice is to start with the vendor name).
Based on the namespace, we suggest TutorialspointDemoBundle.
Bundle name [TutorialspointDemoBundle]:

Bundles are usually generated into the src/ directory. Unless you're
doing something custom, hit enter to keep this default!
Target Directory [src/]:
What format do you want to use for your generated configuration?
Configuration format (annotation, yml, xml, php) [annotation]:
Bundle generation
> Generating a sample bundle skeleton into app/../src/Tutorialspoint/DemoBundle

created ./app/../src/Tutorialspoint/DemoBundle/
created ./app/../src/Tutorialspoint/DemoBundle/TutorialspointDemoBundle.php
created ./app/../src/Tutorialspoint/DemoBundle/Controller/
created ./app/../src/Tutorialspoint/DemoBundle/Controller/DefaultController.php
created ./app/../tests/TutorialspointDemoBundle/Controller/
created ./app/../tests/TutorialspointDemoBundle/Controller/DefaultControllerTest.php
created ./app/../src/Tutorialspoint/DemoBundle/Resources/views/Default/
created ./app/../src/Tutorialspoint/DemoBundle/Resources/views/Default/index.html.twig
created ./app/../src/Tutorialspoint/DemoBundle/Resources/config/
created ./app/../src/Tutorialspoint/DemoBundle/Resources/config/services.yml
> Checking that the bundle is autoloaded
> Enabling the bundle inside app/AppKernel.php
updated ./app/AppKernel.php
> Importing the bundle's routes from the app/config/routing.yml file
updated ./app/config/routing.yml
> Importing the bundle's services.yml from the app/config/config.yml file
updated ./app/config/config.yml
Everything is OK! Now get to work :).
Créer une application Web simple
Ce chapitre explique comment créer une application simple dans le framework Symfony.
Comme indiqué précédemment, vous savez comment créer un nouveau projet dans Symfony.
Nous pouvons prendre un exemple de détails « étudiant ». Commençons par créer un projet nommé
"student" en utilisant la commande suivante.
symfony new student
Après l'exécution de la commande, un projet vide est créé.
Controller
Symfony est basé sur le modèle de développement Model-View-Controller (MVC).
MVC est une approche logicielle qui sépare la logique d'application de la présentation.
Le contrôleur joue un rôle important dans le framework Symfony.
Toutes les pages Web d'une application doivent être gérées par un contrôleur.
La classe DefaultController est située dans "src/AppBundle/Controller". Vous pouvez y créer votre
propre classe Controller.
Déplacez-vous vers l'emplacement "src/AppBundle/Controller" et créez une nouvelle classe

StudentController.
Voici la syntaxe de base de la classe StudentController.
StudentController.php
namespace AppBundle\Controller;
use Symfony\Component\HttpFoundation\Response;
class StudentController {
}
Maintenant, vous avez créé un StudentController. Dans le chapitre suivant, nous discuterons plus en
détail du contrôleur.
Créer un itinéraire(Route)
Une fois le contrôleur créé, nous devons router pour une page spécifique.
Les cartes de routage demandent l'URI à la méthode d'un contrôleur spécifique.
Voici la syntaxe de base pour le routage.
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
/**
* @Route("/student/home")
*/
public function homeAction() {
return new Response('Student details application!');
}
}
Dans la syntaxe ci-dessus, @Route("/student/home") est la route. Il définit le modèle d'URL de la page.
homeAction() est la méthode d'action, où vous pouvez créer la page et renvoyer un objet Response.
Nous aborderons le routage en détail dans le prochain chapitre. Maintenant, demandez l'url
"http://localhost:8000/student/home" et il produit le
résultat suivant.
Résultat
Symfony - Contrôleurs
Le contrôleur est responsable du traitement de chaque requête qui arrive dans l'application Symfony.
Le contrôleur lit une information de la demande. Ensuite, crée et renvoie un objet de réponse au
client.
Selon Symfony, la classe DefaultController est située dans « src/AppBundle/Controller ». Il est défini
comme suit.
DefaultController.php
<?php
class DefaultController extends Controller {

}
Ici, le composant HttpFoundation définit une couche orientée objet pour la spécification HTTP, et le
FrameworkBundle contient la plupart des fonctionnalités du framework "de base".
Objet de requête
La classe Request est une représentation orientée objet du message de requête HTTP.
Création d'un objet de requête
La requête peut être créée à l'aide de la méthode createFromGlobals().
use Symfony\Component\HttpFoundation\Request;
$request = Request::createFromGlobals();
Vous pouvez simuler une requête à l'aide de Globals. Au lieu de créer une requête basée sur les
globals PHP, vous pouvez également simuler une requête.
$request = Request::create(
'/student',
'GET',
array('name' => 'student1')
);
Ici, la méthode create() crée une requête basée sur un URI, une méthode et certains paramètres.
Remplacement d'un objet de requête
Vous pouvez remplacer les variables globales PHP à l'aide de la méthode overrideGlobals(). Il est défini
comme suit.
$request->overrideGlobals();
Accéder à un objet de requête
La demande d'une page Web est accessible dans un contrôleur (méthode d'action) à l'aide de la
méthode getRequest() du contrôleur de base.
$request = $this->getRequest();
Identification d'un objet de requête
Si vous souhaitez identifier une requête dans votre application, la méthode "PathInfo" renverra
l'identité unique de l'url de la requête. Elle est définie comme suit.
$request->getPathInfo();
Objet de réponse
La seule exigence pour un contrôleur est de renvoyer un objet Response.
Un objet Response contient toutes les informations d'une requête donnée et les renvoie au client.
Voici un exemple simple.
Exemple
$response = new Response(‘Default'.$name, 10);
Vous pouvez définir l'objet Response dans JSON comme suit.
$response = new Response(json_encode(array('name' => $name)));

$response->headers->set('Content-Type', 'application/json');
Constructeur de réponse
Le constructeur contient trois arguments -
Le contenu de la réponse
Le code d'état
Un tableau d'en-têtes HTTP
Voici la syntaxe de base.
$response = new Response(
'Content',
Response::HTTP_OK,
array('content-type' => 'text/html')
);
Par exemple, vous pouvez passer l'argument de contenu comme,
$response->setContent(’Student details’);
De même, vous pouvez également passer d'autres arguments.
Envoi de la réponse
Vous pouvez envoyer une réponse au client en utilisant la méthode send(). Il est défini comme suit.
$response->send();
Pour rediriger le client vers une autre URL, vous pouvez utiliser la classe RedirectResponse.
Il est défini comme suit.
use Symfony\Component\HttpFoundation\RedirectResponse;
$response = new RedirectResponse('http://tutorialspoint.com/');
Contrôleur avant
Un seul fichier PHP qui gère chaque requête entrant dans votre application. FrontController exécute le
routage de différentes URL vers différentes parties internes de l'application.
Voici la syntaxe de base pour FrontController.
use Symfony\Component\HttpFoundation\Request;
$request = Request::createFromGlobals();
$path = $request->getPathInfo(); // the URI path being requested
if (in_array($path, array('', '/'))) {

$response = new Response(’Student home page.');
} elseif (‘/about’ === $path) {
$response = new Response(’Student details page’);
} else {
$response = new Response('Page not found.', Response::HTTP_NOT_FOUND);
}
$response->send()
Ici, la fonction in_array() recherche dans un tableau une valeur spécifique.
Symfony - Routage
Les cartes de routage demandent l'URI à la méthode d'un contrôleur spécifique.
En général, tout URI a les trois parties suivantes -
Segment de nom d'hôte
Segment de chemin
Segment de requête
Par exemple, dans URI/URL, http://www.tutorialspoint.com/index?q=data, www.tutorialspoint.com est

le segment de nom d'hôte, index est le segment de chemin et q=data est le segment de requête.
Généralement, le routage vérifie le segment de page par rapport à un ensemble de contraintes.
Si une contrainte correspond, elle renvoie un ensemble de valeurs.
L'une des principales valeurs est le contrôleur.
Remarques
L'annotation joue un rôle important dans la configuration de l'application Symfony.
L'annotation simplifie la configuration en déclarant la configuration dans le codage lui-même.

L'annotation n'est rien d'autre que de fournir des méta-informations sur la classe, les méthodes et les
propriétés.
Le routage utilise largement les annotations.
Même si le routage peut être effectué sans annotation, l'annotation simplifie considérablement le
routage.
Voici un exemple d'annotation.
/**
* @Route(“/student/home”)
*/
// ...
}
Concepts de routage
Considérez la classe StudentController créée dans le projet "student".
// src/AppBundle/Controller/StudentController.php
class StudentController extends Controller {

/**
* @Route(“/student/home”)
*/
// ...
}
/**
* @Route(“/student/about”)
*/
public function aboutAction() {
}
}
Ici, le routage effectue deux étapes. Si vous allez à /student/home, le premier itinéraire est mis en
correspondance, puis homeAction() est exécuté.
Sinon, si vous allez à /student/about, le deuxième itinéraire est mis en correspondance, puis
aboutAction() est exécuté.
Ajout de formats génériques
Considérez que vous avez une liste paginée de dossiers d'étudiants avec des URL comme /student/2
et /student/3 pour les pages 2 et 3 en conséquence.
Ensuite, si vous souhaitez modifier le chemin de la route, vous pouvez utiliser des formats génériques.
Exemple
// src/AppBundle/Controller/BlogController.php

/**
* @Route(“/student/{page}", name = “student_about”, requirements = {"page": "\d+"})
*/
public function aboutAction($page) {
// ...
}
}
Ici, le \d+ est une expression régulière qui correspond à un chiffre de n'importe quelle longueur.
Attribuer un espace réservé
Vous pouvez attribuer une valeur d'espace réservé dans le routage. Il est défini comme suit.
// src/AppBundle/Controller/BlogController.php

/**
* @Route(“/student/{page}", name = “student_about”, requirements = {"page": "\d+"})
*/
public function aboutAction($page = 1) {

// ...
}
}
Ici, si vous allez sur /student, la route student_about correspondra et $page prendra par défaut la
valeur 1.
Redirection vers une page
Si vous souhaitez rediriger l'utilisateur vers une autre page, utilisez les méthodes redirectToRoute() et
redirect().

// redirect to the "homepage" route
return $this->redirectToRoute('homepage');
// redirect externally
\return $this->redirect('http://example.com/doc');
}
Génération d'URL
Pour générer une URL, considérez un nom d'itinéraire, un nom_étudiant et un nom générique, les
noms d'étudiants utilisés dans le chemin de cet itinéraire. La liste complète pour générer une URL est
définie comme suit.

public function aboutAction($name) {
// ...
// /student/student-names
$url = $this->generateUrl(
‘student_name’,
array(‘name’ =>
’student-names’)
);
}
}
ÉtudiantContrôleur
Prenons un exemple simple de routage dans la classe StudentController comme suit.
<?php
/**
*/

$name = 'Student details application';
return new Response(
'<html><body>Project: '.$name.'</body></html>'
);
}
}
Maintenant, demandez l'url "http://localhost:8000/student/home" et cela produit le résultat suivant.
Symfony - Moteur d'affichage(View Engine)
Une couche de vue est la couche de présentation de l'application MVC.
Il sépare la logique d'application de la logique de présentation.
Lorsqu'un contrôleur doit générer du HTML, du CSS ou tout autre contenu, il transmet la tâche au
moteur de modélisation(Templates).
Modèles(Templates)
Les modèles sont essentiellement des fichiers texte utilisés pour générer des documents textuels tels
que HTML, XML, etc. Ils sont utilisés pour gagner du temps et réduire les erreurs.
Par défaut, les modèles peuvent résider dans deux emplacements différents − app/Resources/views/ −
Le répertoire des vues de l'application peut contenir les mises en page de votre application et les
modèles du bundle d'applications.
Il remplace également les modèles de bundle tiers.
vendor/path/to/Bundle/Resources/views/ − Chaque bundle tiers contient ses modèles dans son

répertoire « Resources/views/ ».
Moteur de brindille
Symfony utilise un puissant langage de template appelé Twig.
Twig vous permet d'écrire des modèles concis et lisibles de manière très simple.
Les modèles Twig sont simples et ne traitent pas les balises PHP.
Twig effectue le contrôle des espaces blancs, le sandboxing et l'échappement HTML automatique.
Syntaxe
Twig contient trois types de syntaxe spéciale -
{{ ... }} − Imprime une variable ou le résultat d'une expression dans le modèle.
{% ... %} - Une balise qui contrôle la logique du modèle.
Il est principalement utilisé pour exécuter une fonction.
{# ... #} − Syntaxe des commentaires.
Il est utilisé pour ajouter un commentaire sur une ou plusieurs lignes.
Le modèle de base twig se trouve dans « app/Resources/views/base.html.twig ».
Exemple
Passons en revue un exemple simple utilisant le moteur twig.

<?php

/**
*/
return $this->render('student/home.html.twig');
}
}
Ici, la méthode render() rend un modèle et place ce contenu dans un objet Response.
Déplacez-vous maintenant dans le répertoire "views" et créez un dossier "student" et à l'intérieur de ce

dossier, créez un fichier "home.html.twig". Ajoutez les modifications suivantes dans le fichier.
home.html.twig
//app/Resources/views/student/home.html.twig
<h3>Student application!</h3>
Vous pouvez obtenir le résultat en demandant l'url "http://localhost:8000/student/home".
Par défaut, Twig est livré avec une longue liste de balises, de filtres et de fonctions. Passons en revue
un par un en détail.
Mots clés
Twig prend en charge les balises importantes suivantes −
Faire
La balise do exécute des fonctions similaires à celles d'une expression régulière, à l'exception qu'elle
n'imprime rien. Sa syntaxe est la suivante -
{% do 5 + 6 %}
Inclure
L'instruction include inclut un modèle et renvoie le contenu rendu de ce fichier dans l'espace de noms
actuel. Sa syntaxe est la suivante -
{% include 'template.html' %}
Prolonge (extends)
La balise extend peut être utilisée pour étendre un modèle à partir d'un autre. Sa syntaxe est la
suivante -
{% extends "template.html" %}
Bloc
Le bloc agit comme un espace réservé et remplace le contenu. Les noms de bloc se composent de
caractères alphanumériques et de traits de soulignement. Par exemple,
<title>{% block title %}{% endblock %}</title>
Embed
La balise embed exécute une combinaison d'inclusion et d'extension. Il vous permet d'inclure le
contenu d'un autre modèle. Il vous permet également de remplacer tout bloc défini dans le modèle
inclus, comme lors de l'extension d'un modèle. Sa syntaxe est la suivante -
{% embed “new_template.twig” %}
{# These blocks are defined in “new_template.twig" #}
{% block center %}
Block content
{% endblock %}
{% endembed %}
Filtre
Les sections de filtre vous permettent d'appliquer des filtres Twig réguliers sur un bloc de données de
modèle. Par exemple,
{% filter upper %}
symfony framework
{% endfilter %}
Ici, le texte sera mis en majuscule.
For
La boucle For récupère chaque élément d'une séquence. Par exemple,
{% for x in 0..10 %}
{{ x }}
{% endfor %}
IF
L'instruction if dans Twig est similaire à PHP. L'expression prend la valeur true ou false. Par exemple,
{% if value == true %}
<p>Simple If statement</p>
{% endif %}
Filtres
Twig contient des filtres. Il est utilisé pour modifier le contenu avant d'être rendu. Voici quelques-uns
des filtres notables.
Longueur
Le filtre de longueur renvoie la longueur d'une chaîne. Sa syntaxe est la suivante−
{% if name|length > 5 %}
...
{% endif %}
Lower
Le filtre Lower convertit une valeur en minuscules. Par exemple,
{{ 'SYMFONY'|lower }}
Cela donnerait le résultat suivant -
symfony
De même, vous pouvez essayer les majuscules.
Remplacer
Le filtre de remplacement formate une chaîne donnée en remplaçant les espaces réservés. Par exemple,
{{ "tutorials point site %si% and %te%."|replace({'%si%': web, '%te%': "site"}) }}

Cela produira le résultat suivant -
tutorials point website
Titre
Le filtre de titre renvoie une version en casse de titre de la valeur. Par exemple,
{{ 'symfony framework '|title }}
Symfony Framework
Trier
Le filtre de tri trie un tableau. Sa syntaxe est la suivante -
{% for user in names|sort %}

...
{% endfor %}
Trim
Le filtre trim supprime les espaces (ou autres caractères) du début et de la fin d'une chaîne. Par
exemple,
{{ ' Symfony! '|trim }}
Symfony!
Les fonctions
Twig prend en charge les fonctions. Il est utilisé pour obtenir un résultat particulier. Voici quelques-
unes des fonctions importantes de Twig.
Attribut
La fonction d'attribut permet d'accéder à un attribut "dynamique" d'une variable. Sa syntaxe est la
suivante -
{{ attribute(object, method) }}
{{ attribute(object, method, arguments) }}
{{ attribute(array, item) }}
Par exemple,
{{ attribute(object, method) is defined ? 'Method exists' : 'Method does not exist' }}
Constant
La fonction constante renvoie la valeur constante d'une chaîne spécifiée. Par exemple,
{{ constant('Namespace\\Classname::CONSTANT_NAME') }}
Cycle
La fonction de cycle parcourt un tableau de valeurs. Par exemple,
{% set months = [‘Jan’, ‘Feb’, ‘Mar’] %}

{% for x in 0..12 %}
{ cycle(months, x) }}
{% endfor %}
Date
Convertit un argument en date pour permettre la comparaison de dates. Par exemple,
<p>Choose your location before {{ 'next Monday'|date('M j, Y') }}</p>

Choose your location before May 15, 2017
L'argument doit être dans l'un des formats de date et d'heure pris en charge par PHP.
Vous pouvez passer un fuseau horaire comme deuxième argument.
Décharge
La fonction de vidage vide les informations sur une variable de modèle. Par exemple,
{{ dump(user) }}
Max
La fonction max renvoie la plus grande valeur d'une séquence. Par exemple,
{{ max(1, 5, 9, 11, 15) }}

Min
La fonction min renvoie la plus petite valeur d'une séquence. Par exemple,
{{ min(1, 3, 2) }}
Inclure
La fonction include renvoie le contenu rendu d'un modèle. Par exemple,
{{ include('template.html') }}
Aléatoire
La fonction random génère une valeur aléatoire. Par exemple,
{{ random([‘Jan’, ‘Feb’, ‘Mar’, ‘Apr’]) }}

{# example output: Jan #}
Range
La fonction Range renvoie une liste contenant une progression arithmétique d'entiers. Par exemple,
{% for x in range(1, 5) %}
{{ x }},
{% endfor %}
1,2,3,4,5
Dispositions
Une mise en page représente les parties communes de plusieurs vues, c'est-à-dire, par exemple, l'en-
tête et le pied de page.
Héritage de modèle
Un modèle peut être utilisé par un autre. Nous pouvons y parvenir en utilisant le concept d'héritage
de modèle.
L'héritage de modèle vous permet de créer un modèle de « mise en page » de base qui contient tous
les éléments communs du site Web définis en tant que blocs.
Prenons un exemple simple pour en savoir plus sur l'héritage de modèle.
Exemple
Considérez le modèle de base situé dans "app/Resources/views/base.html.twig".
Ajoutez les modifications suivantes dans le fichier

base.html.twig
<!DOCTYPE html>
<html>
<head>
<meta charset = "UTF-8">
<title>{% block title %}Parent template Layout{% endblock %}</title>
</head>
</html>
Passez maintenant au fichier de modèle d'index situé dans

"app/Resources/views/default/index.html.twig". Ajoutez-y les modifications suivantes.
{% extends 'base.html.twig' %}
{% block title %}Child template Layout{% endblock %}
Ici, la balise {% extend %} informe le moteur de création de modèles d'évaluer d'abord le modèle de
base, qui configure la mise en page et définit le bloc. Le modèle enfant est ensuite rendu.
Un modèle enfant peut étendre la mise en page de base et remplacer le cartouche. Maintenant,
demandez l'url "http://localhost:8000" et vous pourrez obtenir son résultat.
Assets
L'actif gère la génération d'URL et la gestion des versions des actifs Web tels que les feuilles de style
CSS, les fichiers JavaScript et les fichiers image.
JavaScript
To include JavaScript files, use the javascripts tag in any template.

{# Include javascript #}
{% block javascripts %}
{% javascripts '@AppBundle/Resources/public/js/*' %}
<script src="{{ asset_url }}"></script>
{% endjavascripts %}
{% endblock %}
Feuilles de style
Pour inclure des fichiers de feuille de style, utilisez la balise stylesheets dans
n'importe quel modèle
{# include style sheet #}
{% block stylesheets %}
{% stylesheets 'bundles/app/css/*' filter = 'cssrewrite' %}
<link rel = "stylesheet" href="{{ asset_url }}" />
{% endstylesheets %}
{% endblock %}
Images
Pour inclure une image, vous pouvez utiliser la balise image. Il est défini comme suit.
{% image '@AppBundle/Resources/public/images/example.jpg' %}
<img src = "{{ asset_url }}" alt = "Example" />
{% endimage %}
Assets composés
Vous pouvez combiner plusieurs fichiers en un seul. Cela permet de réduire le nombre de requêtes
HTTP et produit de meilleures performances frontales.
{% javascripts
'@AppBundle/Resources/public/js/*'
'@AcmeBarBundle/Resources/public/js/form.js'
'@AcmeBarBundle/Resources/public/js/calendar.js' %}
<script src = "{{ asset_url }}"></script>
{% endjavascripts %}
Symfony - Doctrine ORM
Dans le framework Web Symfony, le modèle joue un rôle important.
Ce sont les entités commerciales.
Ils sont soit fournis par les clients, soit récupérés à partir de la base de données principale, manipulés
selon des règles commerciales et conservés dans la base de données.
Ce sont les données présentées par Views.
Découvrons les modèles et comment ils interagissent avec le système back-end dans ce chapitre.
Modèle de base de données
Nous devons mapper nos modèles aux éléments de la base de données relationnelle principale pour
récupérer et conserver les modèles de manière sûre et efficace.
Ce mappage peut être effectué à l'aide d'un outil ORM (Object Relational Mapping). Symfony fournit
un bundle séparé,
DoctrineBundle, qui intègre Symfony avec un outil ORM de base de données PHP tiers, Doctrine.
Doctrine ORM
Par défaut, le framework Symfony ne fournit aucun composant pour travailler avec les bases de
données.
Mais, il s'intègre étroitement avec Doctrine ORM.
Doctrine contient plusieurs bibliothèques PHP utilisées pour le stockage de bases de données et le
mappage d'objets.
L'exemple suivant vous aidera à comprendre comment Doctrine fonctionne, comment configurer une
base de données et comment enregistrer et récupérer les données.
Doctrine ORM Exemple
Dans cet exemple, nous allons d'abord configurer la base de données et créer un objet Student, puis y
effectuer quelques opérations.
Pour ce faire, nous devons respecter les étapes suivantes.
Étape 1 : créer une application Symfony
Créez une application Symfony, dbsample en utilisant la commande suivante.
symfony new dbsample
Étape 2 : configurer une base de données
Généralement, les informations de la base de données sont configurées dans le fichier

"app/config/parameters.yml". Ouvrez le fichier et ajoutez les modifications suivantes.
parameers.yml
parameters:
database_host: 127.0.0.1
database_port: null
database_name: studentsdb
database_user: <user_name>
database_password: <password>
mailer_transport: smtp
mailer_host: 127.0.0.1
mailer_user: null
mailer_password: null
secret: 037ab82c601c10402408b2b190d5530d602b5809
doctrine:
dbal:
driver: pdo_mysql
host: '%database_host%'
dbname: '%database_name%'
user: '%database_user%'
password: '%database_password%'
charset: utf8mb4
Maintenant, Doctrine ORM peut se connecter à la base de données.
Étape 3 : Créer une base de données
Exécutez la commande suivante pour générer la base de données « studentsdb ». Cette étape est
utilisée pour lier la base de données dans Doctrine ORM.
php bin/console doctrine:database:create
Après avoir exécuté la commande, il génère automatiquement une base de données « studentsdb »
vide.
Vous pouvez voir la réponse suivante sur votre écran.
Created database `studentsdb` for connection named default
Étape 4 : Informations sur la carte
Les informations cartographiques ne sont rien d'autre que des "metadata".

Il s'agit d'un ensemble de règles qui informent Doctrine ORM de la manière exacte dont la classe
Student et ses propriétés sont mappées à une table de base de données spécifique.
Eh bien, ces métadonnées peuvent être spécifiées dans un certain nombre de formats différents, y
compris YAML, XML ou vous pouvez directement passer la classe Student à l'aide d'annotations. Il est
défini comme suit.
Student.php
Ajoutez les modifications suivantes dans le fichier.
Student.php
Add the following changes in the file.

<?php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;

/**
* @ORM\Entity
* @ORM\Table(name = "students")
*/
class Student {
/**
* @ORM\Column(type = "integer")
* @ORM\Id
* @ORM\GeneratedValue(strategy = "AUTO")
*/
private $id;
/**
* @ORM\Column(type = "string", length = 50)
*/
private $name;
/**
* @ORM\Column(type = "text")
*/
private $address;
}
Ici, le nom de la table est facultatif.
Si le nom de la table n'est pas spécifié, il sera déterminé automatiquement en fonction du nom de la
classe d'entité.
Étape 5 : lier une entité
Doctrine crée pour vous des classes d'entités simples.
Il vous aide à construire n'importe quelle entité.
Exécutez la commande suivante pour générer une entité.
php bin/console doctrine:generate:entities AppBundle/Entity/Student
Ensuite, vous verrez le résultat suivant et l'entité sera mise à jour.
Generating entity "AppBundle\Entity\Student"

> backing up Student.php to Student.php~
> generating AppBundle\Entity\Student
Student.php
<?php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;

/**
* @ORM\Entity
* @ORM\Table(name="students")
*/
class Student {
/**
* @ORM\Column(type="integer")
* @ORM\Id
* @ORM\GeneratedValue(strategy="AUTO")
*/
private $id;
/**
* @ORM\Column(type = "string", length = 50)
*/
private $name;
/**
* @ORM\Column(type = "text")
*/
private $address;
/**
* Get id
*
* @return integer
*/
public function getId() {
return $this->id;
}
/**
* Set name
*
* @param string $name
*
* @return Student
*/
public function setName($name) {

$this->name = $name;
return $this;
}
/**
* Get name
*
* @return string
*/
public function getName() {
return $this->name;
}
/**
* Set address
*
* @param string $address
*
* @return Student
*/
public function setAddress($address) {

$this->address = $address;
return $this;
}
/**
* Get address
*
* @return string
*/
public function getAddress() {

return $this->address;
}
}
Étape 6 : validation de la carte
Après avoir créé des entités, vous devez valider les mappages à l'aide de la commande suivante.
php bin/console doctrine:schema:validate
[Mapping] OK - The mapping files are correct.

[Database] FAIL - The database schema is not in sync with the current mapping file
Comme nous n'avons pas créé la table des étudiants, l'entité n'est pas synchronisée.
Créons la table des étudiants à l'aide de la commande Symfony à l'étape suivante.

Étape 7 : créer un schéma
Doctrine peut créer automatiquement toutes les tables de base de données nécessaires pour l'entité
Étudiant. Cela peut être fait en utilisant la commande suivante.
php bin/console doctrine:schema:update --force
Après avoir exécuté la commande, vous pouvez voir la réponse suivante.
Updating database schema...

Database schema updated successfully! "1" query was executed
Cette commande compare ce à quoi votre base de données devrait ressembler avec son apparence
réelle et exécute les instructions SQL nécessaires pour mettre à jour le schéma de la base de données
là où il devrait être.
Maintenant, validez à nouveau le schéma à l'aide de la commande suivante.
php bin/console doctrine:schema:validate
[Mapping] OK - The mapping files are correct.

[Database] OK - The database schema is in sync with the mapping files
Étape 8 : getter et setter
Comme indiqué dans la section Lier une entité, la commande suivante génère tous les getters et setters
pour la classe Student.
$ php bin/console doctrine:generate:entities AppBundle/Entity/Student
Étape 9 : conserver les objets dans la base de données
Maintenant, nous avons mappé l'entité Student à sa table Student correspondante.
Nous devrions maintenant pouvoir conserver les objets Student dans la base de données.
Ajoutez la méthode suivante au StudentController du bundle.
<?php
use AppBundle\Entity\Student;

/**
* @Route("/student/add")
*/
public function addAction() {
$stud = new Student();
$stud->setName('Adam');
$stud->setAddress('12 north street');
$doct = $this->getDoctrine()->getManager();
// tells Doctrine you want to save the Product

$doct->persist($stud);
//executes the queries (i.e. the INSERT query)

$doct->flush();
return new Response('Saved new student with id ' . $stud->getId());

}
}
Ici, nous avons accédé au gestionnaire de doctrine à l'aide de la méthode getManager() via
getDoctrine() du contrôleur de base, puis avons conservé l'objet actuel à l'aide de la méthode persist()
du gestionnaire de doctrine.
La méthode persist() ajoute la commande à la file d'attente, mais la méthode flush() fait le travail réel
(persistance de l'objet étudiant).
Étape 10 : Récupérer des objets de la base de données
Créez une fonction dans StudentController qui affichera les détails de l'étudiant.
/**
* @Route("/student/display")
*/
public function displayAction() {
$stud = $this->getDoctrine()
->getRepository('AppBundle:Student')
->findAll();
return $this->render('student/display.html.twig', array('data' => $stud));
}
Étape 11 : créer une vue
Créons une vue qui pointe vers l'action d'affichage.
Déplacez-vous dans le répertoire des vues et créez un fichier "display.html.twig". Ajoutez les
modifications suivantes dans le fichier.
display.html.twig
<style>
.table { border-collapse: collapse; }
.table th, td {
border-bottom: 1px solid #ddd;
width: 250px;
text-align: left;
align: left;
}
</style>
<h2>Students database application!</h2>

<table class = "table">
<tr>
<th>Name</th>
<th>Address</th>
</tr>
{% for x in data %}
<tr>
<td>{{ x.Name }}</td>
<td>{{ x.Address }}</td>
</tr>
{% endfor %}
</table>
Vous pouvez obtenir le résultat en demandant l'URL "http://localhost:8000/student/display" dans un

navigateur.
Il produira la sortie suivante à l'écran -

Étape 12 : Mettre à jour un objet
Pour mettre à jour un objet dans StudentController, créez une action et ajoutez les modifications
suivantes.
/**
* @Route("/student/update/{id}")
*/
public function updateAction($id) {
$stud = $doct->getRepository('AppBundle:Student')->find($id);
if (!$stud) {
throw $this->createNotFoundException(
'No student found for id '.$id
);
}
$stud->setAddress('7 south street');
$doct->flush();
return new Response('Changes updated!');

}
Maintenant, demandez l'URL "http://localhost:8000/Student/update/1" et cela produira le résultat

suivant.
Il produira la sortie suivante à l'écran -

Étape 13 : Supprimer un objet
La suppression d'un objet est similaire et nécessite un appel à la méthode remove() du gestionnaire
d'entité (doctrine).
Cela peut être fait en utilisant la commande suivante.
/**
* @Route("/student/delete/{id}")
*/
public function deleteAction($id) {
$stud = $doct->getRepository('AppBundle:Student')->find($id);
if (!$stud) {
throw $this->createNotFoundException('No student found for id '.$id);
}
$doct->remove($stud);
$doct->flush();
return new Response('Record deleted!');

}
Symfony - Formulaires
Symfony fournit diverses balises intégrées pour gérer les formulaires HTML facilement et en toute
sécurité.
Le composant Form de Symfony effectue le processus de création et de validation de formulaire.
Il relie le modèle et la couche de vue.
Il fournit un ensemble d'éléments de formulaire pour créer un formulaire html à part entière à partir
de modèles prédéfinis. Ce chapitre explique en détail les formulaires.
Champs de formulaire
L'API du framework Symfony prend en charge un grand groupe de types de champs.

Passons en revue chacun des types de champs en détail.
Type de formulaire
Il est utilisé pour générer un formulaire dans le framework Symfony.
Sa syntaxe est la suivante -
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\FormType;
// ...
$builder = $this->createFormBuilder($studentinfo);
$builder
->add('title', TextType::class);
Ici, $studentinfo est une entité de type Student.
createFormBuilder est utilisé pour créer un formulaire HTML.
La méthode add est utilisée pour ajouter des éléments d'entrée à l'intérieur du formulaire.
Le titre fait référence à la propriété du titre de l'étudiant.
TextType::class fait référence au champ de texte html.
Symfony fournit des classes pour tous les éléments html.
Type de texte
Le champ TextType représente le champ de texte de saisie le plus basique. Sa syntaxe est la suivante -
use Symfony\Component\Form\Extension\Core\Type\TextType;
$builder->add(‘name’, TextType::class);
Ici, le nom est mappé avec une entité.
Type de zone de texte
Rend un élément HTML textarea. Sa syntaxe est la suivante -
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
$builder->add('body', TextareaType::class, array(
'attr' => array('class' => 'tinymce'),
));
Type d'e-mail
Le champ EmailType est un champ de texte rendu à l'aide de la balise HTML5email. Sa syntaxe est la
suivante
use Symfony\Component\Form\Extension\Core\Type\EmailType;
$builder->add('token', EmailType::class, array(
'data' => 'abcdef', ));
Type de mot de passe
Le champ PasswordType affiche une zone de texte de saisie du mot de passe. Sa syntaxe est la
suivante -
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
$bulder->add('password', PasswordType::class);

Cours Configuration Symfony Enasic PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Configuration Symfony Enasic PDF

Transféré par

Droits d'auteur :

Formats disponibles

Tutoriel Symfony

Ce tutoriel vous donnera une introduction rapide au framework Symfony et vous

Symfony est un framework web full-stack. Il contient un ensemble de composants

Symfony a une énorme quantité de fonctionnalités et une communauté active.

Il a une configuration flexible utilisant YAML, XML ou des annotations.

Symfony s'intègre avec une bibliothèque indépendante et une unité PHP.

Le framework Symfony se compose de plusieurs composants, tels que le composant

Symfony est conçu pour optimiser le développement d'applications Web et augmente

Certaines des principales caractéristiques de Symfony Framework sont les suivantes -

Système basé sur Model-View-Controller

Symfony offre beaucoup de flexibilité aux développeurs.

Symfony est un framework Web complet ;

c'est un outil très efficace pour créer des applications web.

De nombreuses entreprises proposent les services Symfony à leurs clients.

Voici quelques-uns des avantages que vous obtenez en utilisant le Framework

Microframework − Symfony peut être utilisé pour développer une fonctionnalité

Vous n'avez pas besoin de redévelopper ou d'installer l'ensemble du framework.

Réduit les frais généraux de temps de développement.

Moteur de template extrêmement mature et fournit rapidement du contenu aux

Compatible et extensible − Les programmeurs peuvent facilement étendre toutes

Framework Symfony - Applications

Drupal 8 - Drupal est un framework PHP open source de gestion de contenu.

Thelia − Thelia est une solution e-commerce basée sur Symfony.

Ce chapitre explique comment installer le framework Symfony sur votre machine.

La deuxième méthode est l'installation basée sur le compositeur.

Avant de passer à l'installation, vous avez besoin de la configuration système

Web server (Any one of the following)

Système d'exploitation : multiplateforme

• Browser Support: IE (Internet Explorer 8+), Firefox, Google Chrome, Safari,

Nous utiliserons le serveur Web de développement intégré PHP pour ce didacticiel.

$ sudo mkdir -p /usr/local/bin

Maintenant, vous avez installé le programme d'installation de Symfony sur votre

symfony new app_name

symfony new HelloWorld

Après avoir exécuté la commande ci-dessus, vous verrez la réponse suivante.

Installer une version spécifique

Si vous devez installer une version spécifique de Symfony, utilisez la commande

symfony new app_name 2.8

Installation basée sur Composer

La commande suivante est utilisée pour créer un projet à l'aide du composeur.

$ composer create-project symfony/framework-standard-edition app_name

Accédez au répertoire du projet et exécutez l'application à l'aide de la commande

Symfony est essentiellement une collection de composants et de bundles de haute

Les bundles sont similaires au plugin mais faciles à créer et à utiliser.

Le framework web Symfony est basé sur l'architecture Model-View-Controller (MVC).

La vue montre les modèles à l'utilisateur de la meilleure façon possible en fonction

Le contrôleur gère toutes les demandes de l'utilisateur, effectue le travail réel en

Le flux de travail comprend les étapes suivantes.

Étape 1 - L'utilisateur envoie une requête à l'application via le navigateur, par

Étape 3 - Le serveur Web transmettra la requête au PHP sous-jacent, qui l'enverra à

Étape 4 - HttpKernel est le composant principal du framework Web Symfony.

Étape 5 - Toute la logique métier se déroule dans le contrôleur cible.

De nouveaux composants utiles sont introduits dans chaque version de Symfony.

Découvrons l'utilisation des composants Symfony dans ce chapitre. Installer un

Les composants Symfony peuvent être installés facilement à l'aide de la commande

Étape 1 - Créez un dossier pour l'application, filesystem-example

Étape 2 - Installez le composant Filesystem à l'aide de la commande suivante.

composer require symfony/filesystem

Étape 3 - Créez un fichier main.php et entrez le code suivant.

$fs = new Filesystem();

Les lignes suivantes utilisent la classe Filesystem.

Étape 4 - Exécutez l'application à l'aide de la commande suivante et elle créera un

Symfony fournit des composants allant de la fonctionnalité simple, par exemple le

require DIR . '/vendor/autoload.php';