Symfony

SYMFONY, UN OUTIL PHP

POUR GAGNER DU TEMPS...

http://symfony.com/
 I : Introduction
1 : Présentation du Framework

2 : Qu'est ce qu'un modèle MVC

3 : Avantages principaux de Symfony (+ utilisations principales)

4 : Mise en place du Framework (Linux + Eclipse)

II Utilisation de Symfony
1 : Architecture du Framework (conventions, principes et structures à connaitre)

2 : Réécriture d’URL

3 : Création d’un Bundle

4 : Modèle : Virtualisation de la base de données

5 : Vue : Génération d'une vue

6 : Contrôleur : / Création d'un Contrôleur

III : Autres
1 : Sécurité

2 : Communauté

3 : Principaux concurrents

Conclusion
 I

Introduction
 1. Présentation du Framework
Depuis ces 10 dernières années le monde du web explose.
De plus en plus d'entreprises utilisent internet pour leurs applications ainsi que pour communiquer
et partager des informations.
Depuis sa création, le langage PHP (PHP: HypertextPreprocessor) a grandement contribué à
l'accessibilité de la création de sites internet.
Parmi tous les modèles de développement nous retiendrons les la structure MVC (Model Vue
Contrôleur) qui permet d'allier rapidité, efficacité et productivité.
Ainsi, comment pourrions-nous intégrer le Framework MVC Symfony dans le cadre d'une application
web afin de d'améliorer son développement?

Informations Générales :

Channel IRC : #symfony-fr

Forum : http://forum.symfony-project.org/ (anglais)

Site Officiel : http://symfony.com

Pré-Requis

Symfony 2.0 webframework php 5.3.2 ou>

ORM doctrine 2.1 php5-sqlite

Intl apc

MySQL
3. Qu'est ce qu'un modèle MVC ?

Une architecture MVC est constituée de trois principaux composants :

- Un contrôleur qui analysera la demande de l'utilisateur et qui récupérera dans le Modèle
(source de données) les informations demandées.
- Un modèle qui représente les sources de données (stockage des informations).
- Une vue qui se charge de mettre en forme les informations qu'elle reçoit du contrôleur.

Cheminement des données:

- Un utilisateur se connecte sur une page
- Il émet une requête afin d'obtenir l'affichage de la page.
- Le server reçoit le message le transmet au contrôleur suivant une route spécifique.
- La route elle, va par rapport à la page demandée, appeler un contrôleur et son action.
- Le contrôleur traite alors l'action et une fois terminée il répond à l'utilisateur avec la page
demandée.

Exemple de situation:
1 Un utilisateur A se connecte à :
http://monsite.com/index.php
2 Le server reçoit une requête provenant de A pour la page index.php
3 La route appel le contrôleur et son action
4 Le contrôleur traite l'action
5 Le server répond à l'utilisateur A en renvoyant le contenu de la page index.php.
4.1 : Avantages principaux de Symfony
Symfony est parmi les meilleures bases de développement. En effet c'est un Framework MVC qui
facilite considérablement le développement asynchrone.
Inspiré de RoR (Ruby on Rails), son code est tout aussi compréhensible ainsi que sa zone
d’administration de type CRUD (Create Read Update Delete) est également très complète.

Il possède :
- Une gestion des routes très puissante
- Un ORM intégré (Doctrine)
- Une gestion complète des formulaires (protection CSRF par exemple, génération
automatique de code etc … ).

La communauté :
La communauté est très active. De plus les auteurs n'hésite pas à mettre des astuces ou des outils
pour faciliter le développement de certaine fonctionnalité (des milliers de plug-in disponible).

La documentation :
La documentation n'est pas négligée. Bien au contraire, elle est trés détaillé complète et dispose de
nombreux exemples. Il reste flexible, en effet plusieurs ORM sont proposé (Doctrine, Propel sont les
plus évolué), il en est de même pour le JavaScript (Prototype, JQuery, Mootools.

Support de nombreux Utilitaires :

Enfin il support de nombreux utilitaires tel que APC, eAccelerator pour accélérer l'exécution de code.

La partie test :
N'oublions pas la partie test car Symfony intègre automatiquement une gestion des tests pour
chaque Bundle/Contrôleur.

4.2 : Mais …
Bien que Symfony soit très puissant, et bien fait il n’en est pas pour autant le meilleur. Avant de se
lancer dans un projet il faut en définir les aspects et c’est cette étape qui détermine qui détermine si
votre Framework doit implanter ou non telle ou telle fonctionnalité.
Il en résulte donc obligatoirement des inconvénients connus et nécessaires venant de sont
environnement général, le web.

Le Framework Symfony est très lourd non en regard de son poids - une quarantaine de méga-octets -
De plus il est nécessaire d'avoir de bonnes bases de programmation avancés afin de d'optimiser le
temps de développement qui reste crucial lors de d'un projet.
5.1 Installation Apache2 / PHP5
Installation pour Ubuntu Version 10.04 LTS lors d’une installation neuve. Les paramètres modifiés
précédemment par vous ne seront évidemment pris en compte.

#Installer Apache2 et PHP5

 sudo apt-get install apache2
 sudo apt-get install php5
 sudo apt-get install libapache2-mod-php5
 sudo /etc/init.d/apache2 restart

#Installer MySQL Server / Client

 sudo apt-get install mysql-server
 sudo apt-get install mysql-client
 sudo apt-get install php5-mysql

# Installation de tous les packages nécessaires:

 sudo apt-get install php5-mysql php5-curl php5-gd php5-idn
php-pear php5-imagick php5-imap php5-mcrypt php5-memcache
php5-mhash php5-ming php5-ps php5-pspell php5-recode php5-
snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl php5-json

#Installation OpenJDK 6 - JAVA

 sudo apt-get install openjdk-6-jdk openjdk-6-jre
5.2 Installation Eclipse Indigo 3.7.1
Téléchargez Eclipse “Classic” 3.7.1
http://www.eclipse.org/downloads/?osType=linux

# L’extraire
 tar xzf eclipse-SDK-3.7.1-linux-gtk.tar.gz

# Déplacez le dans le dossier /opt/ folder

 sudo mv eclipse /opt


 cd /opt


 sudo chown -R root:root eclipse

 sudo chmod -R +r eclipse

# Créez un executable eclipse dans votre dossier

 sudo touch /usr/bin/eclipse
 sudo chmod 755 /usr/bin/eclipse
 sudo nano /usr/bin/eclipse

#Copier le code suivant dans le fichier ouvert par Nano (Commande précédente):

# Créer un raccourcis de menu Gnome

 sudo gedit /usr/share/applications/eclipse.desktop

Copier ce code dans la fenêtre Gedit qui vient de s’ouvrir :

# Launch Eclipse for the first time

 /opt/eclipse/eclipse -clean &

# Default Repertory : /var/www# When is Started, quit and lauch again with normal executable
5.3 Installation Symfony (+GIT)
Lors de cette installation, vous aurez à redémarrer plusieurs fois le service apache, lorsqu’il vous le
sera indiqué, il faudra donc entrer dans la ligne de commande la ligne suivante :

 sudo /etc/init.d/apache2 restart

#GIT est nécessaire pour pouvoir télécharger les “VENDORS”

 sudo apt-get install git-core
 cd /var/www
 sudo wget http://symfony.com/download?v=Symfony_Standard_
Vendors_2.0.8.tgz -O symfony.tgz
 sudo tar zxvf symfony.tgz
 cd Symfony
 php bin/vendors install --reinstall

#Ouvrez votre Navigateur Web et allez à l’adresse suivante :

http://localhost/Symfony/web/config.php

Voici comment résoudre les erreurs indiquées :

**SQLite3 Missing
 sudo apt-get install sqlite3
 sudo apt-get install php5-dev libpcre3-dev
 sudo /etc/init.d/apache2 restart

** File permission
 rm –rf app/cache/*
 rm –rf app/logs/*
 sudo chmod -R 777 app/cache/
 sudo chmod -R 777 app/logs/
 sudo /etc/init.d/apache2 restart

** date.timezone
Il faut changer la propriété date.timezone dans le fichier php.ini (d’apache)
 sudo vi /etc/php5/apache2/php.ini

*Chercher le terme date.timezone( /timezone to search in vi)

*Décommentez la ligne et attribuez lui la valeur suivante : Europe/Paris
*Enregistrez et quittez
 sudo /etc/init.d/apache2 restart
Recommendations :

** PHP accelerator
 sudo pecl install apc
*configure it by default hit enter for each request

*si phpize Error:

 sudo apt-get install php5-dev libpcre3-dev
 sudo pecl install apc

*You should add "extension=apc.so" to php.ini

 sudo vi /etc/php5/apache2/php.ini

*Recherchez les emplacements des extensions dynamiques :

 Sauvez, Quittez en redémarrez Apache

**Install and enable the intl extension

 sudo apt-get install libicu42
 sudo apt-get install libicu-dev
 sudo apt-get install g++

*Set short_open_tag to off in /etc/php5/cli/php.ini*.

 sudo vi /etc/php5/apache2/php.ini

Modifier la ligne short_open_tag = On en short_open_tag = Off

 Sauvez, Quittez en redémarrez Apache
5.4 Configuration de Symfony (SQL)
Après avoir créer votre base de donnée, ainsi que ses utilisateurs et privilèges :

Rendez-vous sur la page : http://localhost/ProgWeb_Projet_Symfony/web/app_dev.php

Cliquer sur configuration et rentrer les informations suivantes :

- Driver : MySQL(PDO)
- Host : Localhost
- Name : Symfony
- Port : 3306
- User : (utilisateur de la Database créée précédemment)
- Password : (Password de la Database créée précédemment)
- PasswordAgain
5.5 Configuration de Symfony (CSRF)
La page suivante propose de configurer le Global Secret par exemple :
caf7c209106a8d2e16dacec7f7c4c72a4

CSRF - Prononcé « Sea Surf » - est une vulnérabilité très répendue et connue dans le monde des sites
internet. En effet, le Cross-Site Request Forgery consiste en l’exécution d’un script malveillant de
façon transparente et inconsciente pour celui qui l’exécute.

il suffit d’envoyer ce script (par des moyens illégaux comme le fait de cacher le script dans une image
par exemple (Sténographie)) à une personne disposant des droits d’utilisateurs suffisant pour faire
l’action choisie, puis de le faire exécuter par cette personne ou évidemment de récupérer les
identifiants de cette personne lors de sa connexion.

Sans qu’elle se sache, elle aura par exemple changé la page d’un site internet, supprimé un article,
modifié des droits ou permit à la personne malveillante de se connecter.

La clé CSRF est donc un moyen préventif, mais nécessite tout de même le respect de notions
importantes en sécurité web :
- Utiliser la méthode POST pour tous les formulaires
- Demander des confirmations aux utilisateurs pour toutes les actions critiques
- S’assurer que son site n’est pas vulnérable au XSS
- Demander les anciennes informations lors de la modification de celles-ci (email/mot de
passe)
- Utiliser la clé CSRF pour chacun des formulaires

Concrètement, pour chaque formulaire, un jeton de validité est créé en fonction de la clé CSRF
originale (voir suite), puis placée dans le formulaire en tant que valeur ainsi que dans une variable de
session.

Il suffit ensuite à la réception des valeurs de formulaire de vérifier qu’elle existe et de comparer la clé
récupérée dans la variable de session ainsi que celle récupérée par POST. Ce qui donne :
Créons donc tout de suite notre clé CSRF

Finalement, à la dernière page si votre utilisateur de session actuelle linux n’a pas les droits suffisant,
il se peut que vous vous retrouviez avec une page d’erreur vous indiquant que Symfony ne peut pas
modifier le fichier lui-même.

Dans ce cas faites le vous-même :

 /var/www/ProgWeb_Projet_Symfony/app/config/parameters.ini
Collez votre Global Secret dans le fichier de configuration à l’endroit indiqué
 II

Utilisation de

Symfony
1 : Architecture du Framework
L'architecture de symfony est plutôt flexible. Nous parlerons de la version standard (Standard
Edition) qui comporte par default la structure recommandée pour une application Symfony:
1 app/: Configuration de l'application
2 src/: Emplacement du code PHP de l'application
3 vendor/: Plugin tiers
4 web/: Dossier racine web
5 Authentification / Autorisation : Sécurité et gestion des utilisateurs

1 Le dossier « app/ »
Il contient le noyau de l'application et toute sa configuration.

2 Le dossier « src/ »
Il contient tous les bundles propres à l'application. Un bundle et généralement associé et
définit comme une fonctionnalité de l'application. Mais il contient aussi des librairies, « Helpers »
(outils d’aide au développement), ou autres outils pour nos contrôleurs.

3 Le dossier « vendor/ »
Ce dossier contiendra tout les plugins tiers que l'on souhaite ajouter à notre application (par
exemple : Forum, blog clés en mains).

4 Le dossier « web/ »
Le dossier web contient tous les éléments public de notre application comme les images,
feuilles de styles(CSS), ou des script (JavaScript).

5 Authentification / Autorisation :
2 : Réécriture d’URL

Dans un Framework MVC la redirection des routes est omniprésente, ce seront-elles qui définiront
quelle action d'un contrôleur sera exécuté lors d'une requête.
Exemple :
Un visiteur Toto se connecte sur monsite.fr/homepage, l'url sera donc monsite.fr (le domaine) suivit
de /homepage (l'URN). Le routage de l'URI commence par la réception de l'URN par le contrôleur
principal. Celui-ci va regarder s'il existe une définition personnalisée de cette URN dans sa table de
route: si une définition existe alors il utilisera cette définition sinon celle par default qui consiste à
prendre le premier paramètre de l'URN comme contrôleur et le second comme action le reste des
URN étant des paramètres de l'action. Dans notre cas il n'existe que le nom du contrôleur. Symfony2
va donc prendre l'action par défaut de notre contrôleur 'homepageController' qui se trouve être
'indexAction'. si cette action par défaut n'existe pas une erreur 404 est affichée.

La personnalisation des routes est ici la fonctionnalité la plus intéressante. En effet quoi de plus
lourd que de renommer un lien qui pointe sur une ancienne page qui n'existe plus?

Il pourrait falloir rechercher le lien sur chaque page de l'application et le remplacer.

Vous aurez vite comprit que si l'application contient 4000 pages cela devient presque irréalisable...
Dans symfony2 si on décide de refactoriser un lien il suffit d'ajouter une route personnalisée.
Reprenons notre utilisateur Toto qui va sur monsite.fr/homepage, cependant on décide de
renommer l’URI pour que cette page soit accessible depuis monsite.fr/index ou monsite.fr/accueil.
Pour cela il suffira de rajouter une règle de route disant: "toute requête provenant de /index ou
/accueil se redirigée vers le contrôleur 'homepageController'".

Il existe 3 façons de définir les routes: le YML, XML ou en PHP, nous nous attarderons sur le format
par défaut – l’YML.
Exemple de redéfinitions de routes pour /accueil au niveau du contrôleur principale (Routing.yml):

De cette manière tout la définition des routes et centralisé clair et paramétrable à souhait.
 3 : Création d’un Bundle

 Déclaration du nouveau BUNDLE

 php app/console generate:bundle --
namespace=Blogger/BlogBundle --format=yml
Tapez entrée par défaut pour toutes les questions

 Nettoyage
Nettoyage car nous n’avons pas besoin de certains des fichiers par défaut créés par le
générateurs
 rm src/Blogger/BlogBundle/Controller/DefaultController.php
 rm -R src/Blogger/BlogBundle/Resources/views/Default/
 rmsrc/Blogger/BlogBundle/Resources/config/routing.yml

 Création et présentation du BUNDLE

 vim src/Blogger/BlogBundle/Resources/views/layout.html.twig

 Insérer le code suivant et enregistrer :

(Suite directe 6 : Contrôleur)

4 : Modèle -> Virtualisation de la BDD
Le modèle d'une application Symfony2 correspond aux sources de données sous forme de code
objet. On appel cette retranscription le mappage, on a ainsi accès à une source de donnée en passant
par un BAL (Database Abstraction Layer).
Symfony2 utilise Doctrine.

 La première étape est la configuration d'un accès à une ressource comme une base de
données MySQL (le plus commun):
 sudo vim app/config/parameters.ini
 Insérez-y le texte suivant

Le fait de séparer la configuration permet de disposer de plusieurs configurations (utilisation de base

de données de test pour un serveur de développement et une seconde pour la production).

Astuce : Il est possible par la suite de créer automatiquement la base de données grâce à la console
avec la commande suivante:
 php app/console doctrine:database:create

La création d'entité
Notre application dispose d'utilisateurs. Pour utiliser l'application, cette dernière doit disposer des
informations sur les utilisateurs (nom, login, mot de passe, droits) qui proviennent de la base de
données. Il faut donc un objet représentant les utilisateurs provenant de la base de données.
Exemple d'objet de l'entité utilisateur:

Astuce : il est également possible de générer une entité à l'aide de la console:

 php app/console doctrine:generate:entity --
entity="AcmeStoreBundle:Utilisateur" --
fields="name:string(255) login:string(255)
password:string(32)"
Mappage
Afin que Doctrine puisse savoir comment interagir avec la base de données il faut définir leurs
caractéristiques grâce à des annotations:

Astuce : l'annotation de la base de données est optionnelle, si elle n'est pas spécifiée, la table
prendra le nom de l'entité (attention aux mots réservé tel que Group et User).

De plus il existe dans doctrine, une multitude de définitions de champs

(http://symfony.com/doc/2.0/book/doctrine.html#book-doctrine-field-types).
Maintenant que Doctrine sait comment interagir avec votre source de données on génère les
accesseur et mutateur:
 php app/console doctrine:generate:entities
Acme/StoreBundle/Entity/Utilisateur

Il est possible de générer le schéma SQL à partir de la console, ainsi vous assurez la compatibilité
mappage ORM et Base de données:
 php app/console doctrine:schema:update --force

Interactions avec la base de données

Voyons maintenant comment interagir avec notre model dans les contrôleurs:
Modification et suppression dans la base de données depuis l’ORM :

Différentes méthodes utiles sont disponibles:

Doctrine dispose également de son propre système de génération de requêtes :

Il existe aussi d’autres méthodes plus complexes que nous n’aborderons pas ici, car elles nécessitent
un niveau de connaissances plus avancé que ce que nous avons vu dans ce tutoriel, à savoir les
méthodes permettant d’exploiter les tables contenant des clés étrangères.

Vous pouvez cependant retrouvez tous les détails nécessaires à ces opérations dans la
documentation Symfony2 disponible à cette adresse : http://symfony.com/doc/current/

Point sur le modèle :

L’exportation des sources de données vers du code objet permet d’optimiser le déploiement d’une
application car la base de données est mappée en objet, ce qui permet de regrouper toutes les
manipulations sur les données en un seul lieu, et ainsi améliorer la qualité, l’évolutivité, la
compréhension du code.
De plus, l’ORM étant présent pour générer les requêtes, les erreurs de syntaxes deviennent quasi-
inexistantes.
5 : Vue -> Génération d’une vue
Symfony2 intègre un nouveau système de template très puissant permettant de gérer ses vues grâce
à un moteur, TWIG.

TWIG est un moteur de template PHP intégré à Symfony2 facilitant grandement le travail en équipe
avec des intégrateurs (ils n’auront qu’à modifier les templates dans : views/ du bundle concerné) et
très puissant permettant de :
- Gérer l’héritage entre templates et layout
- Séparer les couches présentation / métier

Nous remarquerons 3 principaux types de balises :

- {{ variable }} : Affiche le résultat ou contenu d’une valeur / fonction
- {% for page in arrPages %} : Permettant d’exécuter une fonction ou de définir un bloc
- {# Les commentaires #}

Le véritable avantage (et incontestable) est donc l’héritage des templates, pouvant par exemple
intégrer la balise {{ parent() }} ce qui aurait pour effet d’afficher le contenu du template
parent. Mais passons à un exemple de code plus concret :

 Après avoir complètement créé votre Bundle :

 Allez tout d’abord consulter le layout de base de votre projet (seulement pour information):
app/Resources/views/base.html.twig
 Une fois que vous en avez pris connaissance ouvrez le fichier
Default/index.html.twig
 et ajoutez-y les lignes suivantes :

Vous avez donc étendu votre page index.html.twig

avec votre fichier base.html.twig et son contenu
bien entendu.
Mais pas uniquement, vous avez également affiché
un bloc « title » et un bloc « body »

Le bloc Title : le deuxième bloc récupère le contenu

de son parent par héritage puis le concatène à son
propre contenu. Ce qui donne : “Hello World Title”

Le bloc Body : affiche simplement “Hello World

Body” dans les balises body

En plus d’être simple et rapide d’utilisation, TWIG est un moteur de template vraiment très puissant,
principalement via les possibilités d’héritage.
6 : Contrôleur -> Création d’un contrôleur
 Disposition du contrôleur
 vimsrc/Blogger/BlogBundle/Controller/AccueilController.php

Insérer le code suivant et enregistrer :

 mkdirsrc/Blogger/BlogBundle/Resources/views/Accueil/
 vimsrc/Blogger/BlogBundle/Resources/views/Accueil/index.
html.twig

** Insérer le code suivant et enregistrer :

 vim src/Blogger/BlogBundle/Resources/config/routing.yml

** Insérer le code suivant et enregistrer :

 vim app/config/routing_dev.yml
Mettez en commentaires (#) la première route entière
Création du Bundle terminée, rendez-vous ici pour voir le résultat :
http://symblog.dev/app_dev.php/.
 III

Informations

Complémentaires
1 : Sécurité
Authentification :
Ce qui gère l’authentification dans Symfony2 est le firewall (Voir schéma architecture du Framework)

Les Firewalls :
Défini plusieurs zones de sécurités en étant lié à des Providers (Fichier de configuration,
entité Doctrine2, autre source). Il se définit donc par un Pattern ainsi que des informations
de connexion.

L’encoder :
Encode et Hash les mots de passes utilisateur

Autorisation :
Ce qui gère l’autorisation dans Symfony2 est l’Acess Control.

Rôles :
Règles d’autorisations appliquées à des utilisateurs permettant d’autoriser ou non l’accès à
des pages en fonction de celui-ci (ROLE_ADMIN, ROLE_MODERATEUR …)

Access Control :
Vérifie et autorise ou refuse les utilisateurs en fonction de leurs droits.

3 manières différentes de sécurisation de connexions :

- Accès a une page de façon anonyme et sans droits particuliers
- Accès a une page de façon anonyme mais nécessitant tout de même des droits
- Accès à une page de façon identifiée mais sans les droits suffisants

Protection contre les attaques de type :

- CSRF (voir Présentation du Framework -> 5.5 )
- XSS
- Injections SQL

Le fichier security.yml :
Il est un fichier de configuration de la sécurité du Framework, il permet de configurer l’encodeur, la
hiérarchie des rôles, les providers, les firewalls, ainsi que l’Access Control.
2 : Communauté
La communauté de symfony2 est une communauté fidèle car satisfaite de la première version de
Symfony, mais également très fournie et vivante.
Par le biais de forums, chat, documentation ou support technique il est possible de discuter,
apprendre et réaliser des travaux ou projets en étant assuré d’une aide précieuse.
Le support technique quand à lui propose correctifs et solution de façon régulière et réactive.
Tous les éléments sont donc réunis pour garantir une bonne approche de ce Framework.

3 : Principaux concurrents
CakePHP
PHP 4 /5, MySQL, PosrtgreSQL, SQLite, AdoDB
 Très proche de l’esprit Rail

Mojavi
PHP 4 /5, MySQL, PosrtgreSQL, DPO, Creole

Phocoa
PHP5, MySQL, Smarty, Phing
 Venant du Framework Cocoa d’Apple
 Portage en PHP
 Focumentation générée grâce à phpDoc mais complète.

PHP on Trax
PHP5, PEAR::DB
 Documentation Succinte
 Nécessite des extensions PEAR pour certaines fonctionnalités

Seaqull
PHP5, PEAR
 Basé sur Mojavi / Propel / Rails
 Ajout des fonctionnalités : Internationalisation automatique, gestion de tâches, pagination

WACT
PHP4&5, MySQL
 Très porté sur la sécurité

Zend Framework
PHP5.0.4, PECL::PDO
 Grande communauté
 Incorpore de nombreux modules
 Documentation très complète
 Conclusion
Bien que lourd en apprentissage et fonctionnalité, Symfony2 reste un des Framework les plus
appréciés du moment de par son architecture, son modèle MVC, ses cotés « Rails », sa rapidité
d’utilisation une fois bien maîtrisé.
Au cours de nos recherches, nous n’avons tout simplement pas trouvé de site ou forum rabaissant ce
Framework et ça se comprend.

Le gain de temps, la simplicité, l’évolutivité, la communauté, la sécurité, le support, la

documentation, la facilité d’intégration / installation, la possibilité d’utilisation dans Eclipse et
NetBeans sont autant de raisons retrouvées sur toutes les pages de tutoriels, d’exercices, de
définitions ou forums faisant sans cesse pencher la balance en la faveur de Symfony..

Après une première utilisation de ce Framework, il est apparut évident qu’il s’imposera
naturellement dans la réalisation des projets web futurs d’une certaine taille ou complexité
minimum.

Symfony est donc à conseiller à tous ceux :

- Qui ont le temps de s’investir dans un apprentissage assez poussé d’un Framework,
- Qui souhaiteraient réaliser un projet sur le long terme
- Qui disposent d’une ou plusieurs équipes de développement
- Qui ont des besoins de mises à jour régulières (CRUD)

Nous pouvons d’ailleurs constater la récente évolution du site internet DailyMotion vers le
framework Symfony2, ce qui une fois de plus, renforce la notoriété de ce dernier dans le monde du
développement PHP.