View
68.947
Download
2
Category
Preview:
DESCRIPTION
Avec cette nouvelle version de votre framework préféré, de nouvelles fonctionnalités et de nouveaux usages sont apparus. Vous vous demandez comment structurer vos bundles? Comment organiser votre code source? Comment utiliser correctement l'injecteur de dépendance? Venez découvrir au cours de cette session les bonnes pratiques, et quelques astuces, qui vous aiderons dans la réalisation de vos projets avec Symfony2.
Citation preview
Symfony2: 30 astuces et bonnespratiques
Noel GUILBERT
• Développeur Symfony depuis 2005
• Consultant et formateur à SensioLabs
• http://www.noelguilbert.com
• http://twitter.com/noelguilbert
Avant propos
• La version actuelle est en cours de développement
• Une version stable est prévue pour bientôt
• Les éléments présenté durant cette session peuvent changer
Rappel
Les bonnes pratiques que vous avez appris avec symfony 1 sont bienévidemment toujours d'actualité:
• Pas de logique métier dans les templates, ni dans les contrôleurs: uniquement dans les classes métier
• Gérer la présentation dans les vues : pas dans les contrôleurs niles classes métier
• Ne dupliquez pas de code
• Ne modifiez pas directement les classes du framework
• ...
Here we Go !30 astuces et bonnes pratiques à propos de Symfony2
• Par où commencer ?
• Comment organiser votre code ?
• Quel moteur de templates choisir ?
• Configuration
• Gestion des erreurs
• Templating
• Comment utiliser l'injecteur de dépendances ?
• Profiling
• Debugging
• Sécurité
• Performances
1) Par où commencer?
Par où commencer ?• Documentation: http://docs.symfony-reloaded.org/master/
◦ Quick Tour: 1h pour prendre en main le framework
◦ Flat PHP application to Symfony2: un autre tutorial pour prendre en main le framework
◦ Guides: http://docs.symfony-reloaded.org/master/guides
◦ Cookbook: http://docs.symfony-reloaded.org/master/cookbook
• Sandbox: version prépackagée d'une application Symfony2
◦ Pour le moment, c'est la seule méthode recommandée pour démarrer un projet
2) Organisez vos projets!
Organisation des projetsProjets
• Avec Symfony2, aucune structure n'est imposée
• La sandbox est une structure possible, respectant les bonnespratiques
• Si vous voulez que vos projets soit facilement repris en main pardifférents développeurs, gardez le modèle de la sandbox
Organisation des applicationsLes applications
• Avec Symfony2, vous aurez généralement besoin que d'uneseule application:
◦ Le système de sécurité permet de cloisonner efficacementchaque fonctionnalité (backend/frontend)
◦ Les classes et services sont chargés uniquement si vous lesutilisez: pas d'impact sur les performances
Multi applications
• Vous pouvez avoir besoin de plusieurs applications:
◦ Projet avec beaucoup de fonctionnalités, et avec un besoincloisonnement
◦ Séparation importante entre les différentes fonctionnalités
• Généralement, vous avez surtout besoin de créer un nouveauprojet
Organisation en multi-applicationsExemple de projet avec plusieurs applications
/application1/Application1Kernel.php...
/application2/Application2Kernel.php...
/web/application1.phpapplication2.php...
Organisation des bundlesLes bundles
• Organisez vos bundles en briques logicielles: chaque bundle est responsable d'unefonctionnalité:
◦ ForumBundle
◦ BlogBundle
◦ UserBundle
◦ ShopBundle
src/Sensio/Bundle/
UserBundle/Controller/
UserController.phpShopBundle/
Controller/OrderController.php
3. Isolez vos classes métiers
Isolez vos classes métiersProblématique
• Souvent, vous avez des classes qui sont réutilisées dans plusieurs bundles
• Ces classes peuvent même être utilisées dans des projets n'utilisant pas Symfony2
Solution
• Les bundles sont uniquement des liens entre votre code métier et le framework
• Vous pouvez donc avoir des classes en dehors de vos bundles
• C'est le choix d'architecture qui a été fait pour le framework: Bundles vs Components
Séparez vos classes métiers desbundles
Exemple de structure avec une séparation des classes métiers et desbundles
src/Sensio/Bundle/
UserBundle/OrderBundle/
Business/ <--------- Classes metiersForm/
User.phpValidator/
Order.phpEntity/ <--------- Entites Doctrine2
User.php
Séparez vos classes métiers desbundles
Grâce à l'autoloading, vous pouvez très simplement charger des classes qui ne sont pas dans un bundle.
<?php
use Symfony\Component\ClassLoader\UniversalClassLoader;
$loader = new UniversalClassLoader();$loader->registerNamespaces(array(
'Sensio' => __DIR__.'/../src',));
$loader->register();
# in your applicationnew Sensio\Business\Form\User();
Spécificité pour les entitésDoctrine2
Déclarez les mappings
Il faut indiquer à Doctrine2 où sont les entités, lorsqu'elles ne sont pas dans un bundle:
# app/config/config.ymlorm:
auto_generate_proxy_classes: %kernel.debug%mappings:
Sensio:type: annotationprefix: Sensiodir: %kernel.root_dir%/../src/Sensio/Entity
4: Utilisez votre namespace
Utilisez votre propre namespaceGérez votre propre namespace:Vos projets doivent avoir leurs propre namespaces:
• n'utilisez pas le namespace Sensio de la sandbox!
◦ Sensio
◦ YourCompany
◦ MyProject
<?php
namespace Sensio;
class Product{
/* ... */}
5: Bibliothèque externes
Bibliothèques externes• Par défaut, la sandbox est fournie avec toutes les bibliothèques externe qu'elle supporte:
◦ Symfony2
◦ Twig
◦ Doctrine
◦ SwiftMailer
◦ Assetic
• Retirez les bibliothèques que vous n'utilisez pas:
◦ Supprimez les répertoires correspondants
◦ Retirez les de la configuration de l'autoloader
◦ Désactivez les bundles associés
6: Ne divulgez plus vos mots de passes
Ne divulgez plus vos mots de passesUtilisez des variables d'environnement
• Vous pouvez définir des variables d'environnement spécifiques pour vos projets Symfony2:
◦ Les variables doivent être préfixées par SYMFONY_ _
◦ Vous pouvez ensuite utiliser ces paramètres naturellement dans vos fichiers deconfiguration
Ne divulgez plus vos mots de passesConfiguration des variables d'environnement depuis un VirtualHost
# VirtualHost configuration<VirtualHost *:80>
Servername www.domain.tld
# ...
SetEnv SYMFONY__DATABASE_USERNAME "sflive"SetEnv SYMFONY__DATABASE_PASSWORD "s3cr3t"
</VirtualHost>
# Application configuration: app/config/config.yml
doctrine:dbal:
username: %database_username%password: %database_password%
7: Configuration: le format INI
Le format INI
Généralement, n'utilisez pas le format INI pour vos projets:
• La syntaxe est limité
• Pas de validation
Le format INILe format INI peut être utile dans certains cas
Si vous souhaitez fournir une application paramétrable à des profils peu techniques, vous pouvezutiliser le format INI.
; blog.ini[parameters]blog.admin.email = noelguilbert@gmail.comblog.admin.name = Noël
Importez ce fichier dans la configuration de votre bundle:
<container><imports>
<import resource="blog.ini" /></imports><services id="blog.notification.email"
class="Sensio\BlogBundle\Notification\Email"><argument key="admin_email">%blog.admin.email%</argument><argument key="admin_name">%blog.admin.name%</argument>
</services></container>
8: Utilisez Twig
Utilisez Twig• Deux moteurs de templates sont disponibles par défaut avec Symfony2:
◦ PHP
◦ Twig
• Twig est le moteur de template recommandé :
◦ Protection XSS
◦ Mode sandbox
◦ Limite la logique métier dans les templates
◦ Utilisable très facilement par les intégrateurs HTML
9: Surchargez les pages d'erreurs
Surcharge des pages d'erreurs
Plusieurs solutions sont à votre disposition:
• Surcharger uniquement les templates
• Surcharger les contrôleurs
• Créer un service pour surcharger le comportement du framework
Surcharge des pages d'erreurs• Surchargez les templates:
◦ app/view/FrameworkBundle/error.html.twig
◦ app/view/FrameworkBundle/error.xml.twig
◦ app/view/FrameworkBundle/error.json.twig
<!-- app/view/FrameworkBundle/error.html.twig --><!DOCTYPE html><html>
<head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head><body>
<h1>Oops! An Error Occurred</h1><h2>The server returned a "{{ status_code }} {{ status_text }}".</h2><div>
Something is broken. Please e-mail us at [email] and let us knowwhat you were doing when this error occurred. We will fix it as soonas possible. Sorry for any inconvenience caused.
</div></body>
</html>
Surcharge des pages d'erreurs• Par défaut, les exceptions sont récupérées par un controller.
• Vous pouvez utiliser un autre contrôleur
# app/config/config.yml
framework:exception_controller: Sensio\HelloBundle\Controller\ErrorController
• Votre contrôleur doit implémenter une méthode showAction
<?php
namespace Sensio\HelloBundle\Controller;
class ErrorController extends ContainerAware{
public function showAction(FlattenException $exception){
// do whatever you want here
return new Response(/* ... */);}
}
Surcharge des pages d'erreurs
• Si vous voulez complètement surcharger le mécanismed'exception de symfony, vous pouvez utiliser un service
• Ce service doit écouter l'évènement core.exception
Surcharge des pages d'erreursDéclaration du service
<service id="sensio.error_handle" class="Sensio\Error\ExceptionHandler"><tag name="kernel.listener"
event="core.exception"method="handleException"priority="-128"
/></service>
Implémentation du service
<?php
namespace Sensio\Error;
class ExceptionHandler{
public function handleException(EventInterface $event){
$exception = $event->get('exception');// do whatever you want here
return new Response(/* ... */);}
}
10) Contrôleurs
ContrôleursLes contrôleurs ne doivent pas hériter de la classe Controller duFrameworkBundle.
<?php
namespace HelloBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class BadController extends Controller{
// your code here}
ContrôleursPourquoi ce n'est pas conseillé:
• Les méthodes fournies par cette classe ne sont que desraccourcis
• Surtout utile pour débuter avec le framework
• Cette dépendance n'est pas obligatoire
• L'overhead ajouté n'apporte aucun bénéfice
ContrôleursCe contrôleur est correct:
<?php# Sensio/HelloBundle/Controller/Controller.phpnamespace Sensio\HelloBundle;
class SimplestController{
/*** @extra:Route("/hello")*/public function hello(){
return new Response('Hello World');}
}
ContrôleursOui, les contrôleurs peuvent être de simples objets PHP
Avantages:
• Aucune dépendance
• Pas d'overhead
• Très facile à comprendre
Inconvénients:
• Aucun moyen d'accéder aux différentesfonctionnalités du framework: request,entity_manager, etc.
ContrôleursSolution 1: Hériter de ContainerAware
<?php
namespace HelloBundle\Controller;
use Symfony\Component\DependencyInjection\ContainerAware
class GoodController extends ContainerAware{
public function indexAction(){
$em = $this->container->get('doctrine.orm.entity_manager');}
}
Avantages:
• Plus de dépendances vers Controller
• Les mêmes fonctionnalités sont disponibles
• Pas d'overhead
ContrôleursSolution 2: utiliser des services en tant que controlleurs
Avantages:
• Vous contrôlez vos dépendances via l'injecteur de dépendances
• Vous pouvez tester unitairement vos contrôleurs
ContrôleursDéfinition d'un contrôleur via l'injecteur de dépendances
• Définition du service
<!-- HelloBundle/Resources/controllers.xml --><service id="better_controller" class="HelloBundle\Controller\ServiceController" />
• Configuration du routing
my_route:defaults: { _controller: better_controller:index }
• Votre contrôleur est toujours un objet PHP classique
<?phpnamespace HelloBundle\Controller;
class ServiceController{
public function indexAction(){}
}
ContrôleursExemple: un contrôleur ayant accès aux services suivant:
• Le service de templating
• L'entity manager
Configuration du service:
# HelloBundle/Resources/controllers.xml<service id="product_controller" class="HelloBundle\Controller\ProductController">
<argument type="service" id="templating" /><argument type="doctrine.orm.entity_manager" />
</service>
ContrôleursImplémentation du contrôleur:
<?php
namespace HelloBundle\Controller;
class ProductController{
public function __construct(EngineInterface $templating, EntityManager $em){
$this->templating = $templating;$this->em = $em;
}
public function indexAction(){
$products = $this->em->getRepository('HelloBundle:Product')->findAll();
return $this->templating->renderResponse('HelloBundle:Product:list.html.twig',array('products' => $products)
);}
}
11: Inclusion des assets
Inclusions des assetsAssets avec Symfony2
• Avec Symfony2, il n'y a plus de gestionnaire d'assets permettant d'ajouter les styles css àutiliser
• Utilisez plutôt les blocs twig pour gérer vos assets.
Dans votre layout de base:
{# app/views/base.html.twig #}<html>
<head>{%block stylesheets %}{% endblock %}
</head><body>
{# ... #}{%block javascripts %}{% endblock %}
</body></html>
Inclusions des assetsChoisissez les assets à utiliser directement dans vos templates:
{# HelloBundle/Resources/views/Default/index.html.twig #}{% block stylesheets %}
<link href="{{ assets("bundles/hello/css/styles.css") }}" rel="stylesheet" />{% endblock %}
{% block javascripts %}<script src="{{ assets("bundles/hello/js/script.js") }}" type="text/javascript"></script>
{% endblock %}
12: Utilisez les macros Twig
Twig: Utilisez les macrosCas d'utilisation classique: des boutons html personnalisés
Le code HTML correspondant pourrait être le suivant:
<a href="#" class="button"><span><span><span>
Nice Button</span>
</span></span>
</a>
Twig: Utilisez les macrosRéalisez un macro permettant de réutiliser facilement ce codeHTML
{# HelloBundle/Resources/views/macro.html.twig #}{% macro button(url, text) %}
<a href="{{ url }}" class="button"><span>
<span><span>
{{ text }}</span>
</span></span>
</a>{% endmacro %}
Réutilisez cette macro dans vos templates:
{# HelloBundle/Resources/views/Default/index.html.twig #}
{% from "HelloBundle::macro.html.twig" import button %}
{{ button("Nice Button!") }}
13: Internationalisation
InternationalisationInternationalisez vos projets
• Parce que vous ne savez pas comment votre projet va évoluer
• Parce que l'impact en terme de performances est négligeable
• Parce que implémenter l'internationalisation après coup vous prendra beaucoup de temps
Injection de dépendance
14) Apprenez à l'utiliser
L'injecteur de dépendance est à la base du framework.
Domptez-le, et vous aurez le pouvoir de Symfony2 entre vosmains!
Apprenez à utiliser l'injecteur dedépendances
Ressources sur ce sujet:
• http://www.slideshare.net/fabpot
• http://fabien.potencier.org/article/13/introduction-to-the-symfony-service-container
• http://components.symfony-project.org/dependency-injection/
15) Injection de dépendences: règles de
base
Règles générales:
• Les classes doivent être utilisables sans le conteneur
• Seul le conteneur connait les dépendances, et pas l'inverse
• Ce n'est pas LA solution à tous vos problèmes
16) Utilisez le format XML
Définir vos servicesUtilisez le format xml pour décrire vos services:
• Un peu plus verbeux
• Mais beaucoup plus simple à appréhender et à comprendre
• Autocomplétion dans les éditeurs XML qui le supporte
17) Injecteur de dépendances:
Injecteur de dépendancesQuand l'utiliser?L'injecteur de dépendances doit être utilisés pour les objetsmétiers qui ont une portée globale:
• request
• http kernel
• entity manager
• caching driver (memcache, apc, ...)
18) Quand NE PAS l'utiliser?
Injecteur de dépendancesQuand ne pas l'utiliser ?L'injecteur de dépendances ne doit pas être utilisés dans lescas suivants:
• Retrouver une instance d'un objet métier (i.e. un produitdans une base de données)
• Pour un objet n'ayant pas une portée globle: un objet métiern'étant utilisés que dans un controleur, par exemple
19) Ne pas injecter le container
Ne pas injecter le containerIl ne faut pas injecter le container dans les objets:
• Cela crée une dépendance forte avec le conteneur alors que vous avez rarement la nécessité
• Vous ne pourrez plus utiliser vos classes sans le conteneur
<?php
namespace Sensio\Product
class Manager{
public function __construct($container){
$this->dbh = $container->get('doctrine.dbal.default_connection');}
}
Injecteur de dépendancesInjecter directement le service concerné:
<?php
namespace Sensio\Product
class Manager{
public function __construct($dbh){
$this->dbh = $dbh;}
}
21) Sécurité
SécuritéLe module de sécurité est une part très spécifique de laconfiguration de votre projet
Vous y définissez:
• Comment retrouver vos utilisateurs
• A quelles ressources il peuvent accéder
• Comment il peuvent accéder à ces resources
La bonne pratique est de définir ces informations dans un fichier spécifique
SécuritéExemple:
# app/config/security.ymlsecurity:
encoders:Symfony\Component\Security\Core\User\User: sha1
providers:main:
users:foo: { password: 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33, roles: ROLE_USER }
facebook: true
firewalls:main:
pattern: /.*http-basic: truelogout: true
access_control:- { path: /admin, role: ROLE_ADMIN }- { path: /public, role: ROLE_ANONYMOUS }- { path: /.*, role: ROLE_USER }
22) Profiling
Profiling:Surveillez vos performances:
• nombre de requêtes
• temps d'exécution
• mémoire utilisée
Profiling:Surveillez également vos redirections:
• Les actions réalisant des redirections font très souvent des dizaines de requêtes
• En environnement de développement, Symfony2 intercepte ces redirections pour vous permettred'analyser l'exécution
23) Profiling en production
Profiling:
Il arrive parfois qu'un problème survienne en production sans quevous soyez capable de comprendre le problème.
• Avec symfony 1, une des solutions est d'activer le debug letemps de comprendre ce qu'il se passe.
• Avec Symfony2, vous pouvez activer le profiler en productionsans activer l'affichage des erreurs.
Activer le profiling en production:
# app/config/config_prod.ymlframework:
profiler: { only_exceptions: true }
Profiling:Importer un dump
24) Utilisez les annotations
Utilisez les annotationsLes annotations permettent de définir des comportements, des éléments de configuration, etc...
<?php
/*** @orm:Entity*/class User{
}
Ce format de configuration est très pratique:
• Il permet de définir des comportements directement dans les classes concernés
• Tout est centralisé: vous n'avez plus à vous rappeler dans quel fichier tel ou tel comportement estdéfini
25) FrameworkExtraBundle
FrameworkExtraBundle
Le bundle FrameworkExtraBundle vous donne accès à d'avantagesd'annotations pour configurer:
• Le routing
• La ou les méthodes HTTP possible pour une règle de routing(GET, POST, ...)
• les templates à utiliser
• Le cache HTTP
• Convertir des paramètres de requêtes (en entité Doctrine, parex.)
FrameworkExtraBundleExemple de contrôleur:
<?php
class AwesomeController extends ContainerAware{
/*** @extra:Route("/awesome/controller")* @extra:Method("GET")* @extra:Template("SensioHelloBundle:Default:index.html.twig")* @extra:Cache(maxage=600)*/public function indexAction(){
}}
Performances
Optimisez vos performances grâce à Symfony2.
26) Optimisez l'autoloading
Autoloading• L'un des goulot d'étranglement classique en PHP est l'autoloading.
• Les performances exceptionnelles de Symfony2 s'expliquent en partie par des solutions visant àoptimiser le chargement des classes du framework
• Vous pouvez également profiter de ces améliorations pour vos projets, grâce aux extensions del'injecteur de dépendance.
<?php
namespace Sensio\UserBundle\DependencyInjection;
class UserExtension extends Extension{
public function load(array $config, ContainerBuilder $container){
/* ... */
$this->addClassesToCompile(array('Sensio\UserBundle\Model\User'
));}
}
AutoloadingVos classes sont "compilées" dans un fichier unique:
<?php
# app/cache/prod/classes.php/* ... */
namespace Sensio\UserBundle\Model {class User {
/* your code */}
}
Avantages:
• Plus besoin de passer par l'autoloader: vos classes sont forcéments chargées à chaque requêteHTTP
• Moins d'accès disque pour charger les classes
• Ce fichier est mis en cache par les gestionnaire d'opcode (APC, EAccelerator, XCache)
Autoloading
L'arme secrète de Symfony2 est à votre portée!
• Attention : cette fonctionnalité peut avoir l'effet inverse si elleest trop utilisée
27) Cache Warmer
Cache WarmerLa commande cache:warmup permet de pré-compiler tous les fichiers nécessaire en cache:
• Templates
• Injecteur de dépendance
• Routing
• Autoloading
$> php symfony cache:warmup
28) Doctrine: vérifier laconfiguration
Doctrine: vérifier la configuration
Une commande dédiée vous permet de vérifier la bonneconfiguration de Doctrine2 dans Symfony2:
$> php app/console doctrine:ensure-production-settings
29) Routing
Routing: Utilisez le router ApacheConfigurez Symfony pour utiliser le matcher Apache:
# app/config/config.yml
framework:router: { matcher: apache }
Exportez vos règles de routing en RewriteRules:
$> php app/console router:dump > rewrite.conf
30) Assets
AssetsUtilisez assetic pour de meilleures performances:
{# HelloBundle/Resources/views/Default/index.html.twig #}{% block stylesheets %}
{% stylesheet filter="yui_css", output="/css/main.css","@HelloBundle/Resources/public/css/reset.css""@HelloBundle/Resources/public/css/styles.css"
%}<link href="{{ asset_url }}" rel="stylesheet" />{% endstylesheet %}
{% endblock %}
{% block javascripts %}{% javascript filter="closure", output="/js/script.js",
"@HelloBundle/Resources/public/js/jquery.js""@HelloBundle/Resources/public/js/hello.js"
%}<script src="{{ asset_url }}" type="text/javascript"></script>{% endjavascript %}
{% endblock %}
Questions ?Merci de votre attention!
Recommended