Accueil > symfony > Menez le web à la baguette avec symfony

Menez le web à la baguette avec symfony

Introduction

Chez Excilys, nous ne sommes pas sectaires. Bien que le groupe concentre son activité autour des technologies Java, bon nombre de collaborateurs s’intéressent à d’autres langages ou technologies. Après Android et Grails, je vais vous présenter le framework PHP symfony au travers d’une série d’articles dans lesquels nous construirons petit à petit une application web.

Commençons par un rapide aperçu de PHP.

elephpant

PHP: Hypertext Preprocessor est un langage de script créé par Rasmus Lerdorf en 1994. Bien que le langage soit majoritairement utilisé pour créer des sites/applications web (du fait qu’il propose beaucoup d’outils allant dans ce sens), il est tout à fait possible d’utiliser PHP pour créer des applications type script d’administration système, voire des applications graphiques (avec les bindings GTK par exemple).

Depuis ses débuts où il était écrit en Perl, PHP a évolué petit à petit pour devenir un langage objet (grosso modo depuis sa version 5), avec de nombreuses facilités telles que :

  • un accès très simple aux SGBD (MySQL, PostGreSQL…),
  • une manipulation de XML via DOM ou SimpleXML,
  • la possibilité de générer des images via GD,
  • de nombreuses autres API.

Durant de nombreuses années, PHP a été considéré comme un langage d’amateur, tout juste bon à bidouiller son site perso (PHP signifiait initialement Personal Home Page :-)). Il est vrai que cette techno n’a pas tous les atouts de son côté :

  • apparition tardive et pas forcément bien implémentée d’une syntaxe orientée objet,
  • incohérence (ou absence ?) de conventions de nommage et de paramétrage des fonctions des API,
  • nombreux problèmes de sécurité (aussi bien dans le langage que dans les principales applications).

Cependant, il est à noter que PHP a tout de même certains avantages :

  • langage assez simple à apprendre et à utiliser (un hello world consiste à écrire “Hello world!” dans un fichier .php),
  • performances  convenables (et de nombreux tunings peuvent être effectués pour la scalability : cache, opcodes etc.),
  • documentation et aide très faciles à trouver.

Comme nous l’avons vu, PHP a longtemps été délaissé par les professionnels. Cependant la tendance s’inverse, le monde de l’entreprise semble de plus en plus s’intéresser (et contribuer) à cette technologie. La preuve en est avec la pléthore de frameworks PHP apparus depuis quelques années :

  • symfony,
  • Zend Framework,
  • CakePHP,
  • Code Igniter.

Les outils, bonnes pratiques et design patterns qui font le succès de langages tels que Java commencent à faire leur apparition au sein de la communauté PHP :

Présentation de symfony

symfonyLe but de cet article, puis de ses petits frères, sera de nous familiariser avec l’un des frameworks PHP les plus répandus actuellement, à savoir symfony. symfony est développé par Sensio Labs, une entreprise française spécialisée dans le développement web et les technologies Open Source.

Ce framework est intéressant sous plusieurs aspects. Outre le fait qu’il soit open source, il est développé par une entreprise, pour des entreprises. Sensio Labs assure donc le support adéquat, avec notamment des formations permettant de maitriser la bête en quelques jours. Côté documentation, nous sommes gâtés : tutoriels officiels (sous forme de calendrier de l’Avent), livres sous format électronique (gratuits) ou papier, forums, ainsi qu’une foultitude de sites de la communauté.

symfony, tout comme Maven ou Ruby on Rails, prône le paradigme “convention over configuration”. Toutefois, rien n’empêche le développeur téméraire de bousculer totalement le “normal” et adapter la structure à son goût (ou à de l’existant), de remplacer certains composants etc. Les différentes briques du frameworks se veulent les moins couplées possibles, de manière à pouvoir les remplacer ou les supprimer si elle ne sont pas nécessaires dans un projet.

Dans sa prochaine version majeure (actuellement en heavy development), Symfony 2 (notez la majuscule cette fois !) utilisera différents composants récemment développés, qui peuvent tout à fait être intégrés dans des projets utilisant (ou non) un autre framework : gestion du format YAML, event dispatcher, injection de dépendances, templating etc.

“Assez de blabla, plus de concret !”, entends-je dans le fond de la salle (près du radiateur…). Passons donc à l’action !

Présentation du projet : Plum

Afin de plonger dans le framework, je vous propose de développer directement une application web, que nous nommerons Plum (pour Plum Link & Url Manager par exemple, ou tout ce que votre imagination trouvera). Cette application aura pour principal fonction d’agréger des marques-pages, à la manière de del.icio.us. Un peu de fonctionnel, alors.

On désire pouvoir stocker des bookmarks, qui ne sont rien de plus que des URLs associées éventuellement à une description, ajoutées à une certaine date. À ces URLs, on va associer zéro ou plusieurs tags, qui sont en fait des mots-clés permettant de retrouver facilement des bookmarks liés à un sujet particulier.

Exemple :

URL : http://www.excilys.com
Description : Site du groupe Excilys
Date de création : 25/12/2009
Tags : excilys, développement, java, javaee, trop bien

Mise en place de l’environnement

À partir de maintenant, je suppose que vous disposez déjà d’un environnement Apache/PHP/MySQL fonctionnel. Si ce n’est pas le cas, de nombreux outils et tutoriels vous aideront si vous souhaitez installer Plum chez vous.

La récupération de symfony peut se faire de trois façons : par SVN, PEAR ou en téléchargeant une archive .zip ou .tgz. Nous choisirons la troisième solution (car elle nécessite moins d’utilitaires prérequis). Nous allons travailler sur la version 1.4.1 de symfony, sortie récemment et disposant d’un Long Term Support (LTS). Elle est à télécharger ici.

Dans la suite du projet, j’utiliserai le répertoire ~/prog/php/ comme répertoire de travail, mais vous êtes libres de l’adapter à votre OS/goût. Après avoir extrait l’archive symfony-1.4.1.tgz dans ~/prog/php, un dossier symfony-1.4.1 a dû être créé. Il contient l’ensemble du framework (dans lib/) ainsi que des assets et scripts de lancement (dans data/) et les tests unitaires/fonctionnels du framework (dans test/).

La première étape est de créer la structure du projet :


1
2
3
4
5
6
7
8
9
10
11
12
bastien:php $ mkdir plum
bastien:php $ cd plum/
bastien:plum $ ../symfony-1.4.1/data/bin/symfony generate:project plum
>> dir+      /home/bastien/prog/php/plum/log
>> file+     /home/bastien/prog/php/plum/symfony
>> dir+      /home/bastien/prog/php/plum/test
>> dir+      /home/bastien/prog/php/plum/test/functional
>> dir+      /home/bastien/prog/php/plum/test/bootstrap
...
>> tokens    /home/bastien/prog/php/plum/config/doctrine/schema.yml
>> tokens    /home/bastien/prog/php/plum/lib/form/BaseForm.class.php
bastien:plum $

Explications : rien de bien sorcier, on créé un répertoire qui va contenir notre projet, on se met dedans et on appelle le script principal de symfony (que nous venons d’extraire), avec les paramètres suivants :

  • generate:project : c’est la commande symfony que nous invoquons, qui va… générer un projet :-)
  • plum : c’est le seul et unique paramètre de la commande, ici le nom de notre projet

Maintenant que nous avons un projet, il faut y ajouter une application (un projet peut contenir plusieurs applications). Nous allons dans un premier temps générer le frontend, c’est-à-dire l’application principale que verront les utilisateurs lambda :


1
2
3
4
5
6
bastien:plum $ ./symfony generate:app frontend
>> dir+      /home/bastien/prog/php/plum/apps/frontend/templates
>> file+     /home/bastien/prog/php/plum/apps/frontend/templates/layout.php
...
>> dir+      /home/bastien/prog/php/plum/test/functional/frontend
bastien:plum $

Notez que maintenant nous utilisons directement le script ./symfony (qui appelle derrière le script que nous appelions précédemment). La commande generate:app est invoquée pour générer une application nommée frontend, qui sera accessible dans un sous-dossier de apps/.

Analyse du projet généré

En retour, le script va nous générer un tas de dossiers et de fichiers, qui constituent l’arborescence de base d’un projet symfony :arborescence-projet-symfony

  • apps : contient les applications du projet (typiquement le frontend que nous venons de générer)
  • cache : ici sera stocké le cache de l’application (afin de servir le client plus rapidement en évitant par exemple des parsings de configuration ou des remplissages de templates)
  • config : stocke tous les fichiers de configuration du projet (base de données, projet, rsync etc.)
  • data : c’est dans ce répertoire que seront mis entre autres les fixtures (des jeux de tests fixes à insérer dans une BDD)
  • lib : contiendra des classes PHP, de préférence globales au projet (en opposition aux classes ayant un scope application ou module, comme nous le verrons par la suite)
  • log : dossier dans lequel les logs applicatifs seront enregistrés
  • plugins : le répertoire des plugins externes (par exemple un plugin de gestion des comptes utilisateurs)
  • test : c’est là que nous placerons nos tests unitaires / fonctionnels
  • web : c’est le seul répertoire qui sera accessible depuis l’extérieur (c’est-à-dire par des requêtes sur le site), c’est donc ici que nous mettrons les images, les CSS etc.
  • symfony : ce n’est ni plus ni moins qu’un « raccourci » vers le script principal de symfony que nous avons utilisé tout à l’heure, il nous évitera d’avoir à retrouver son chemin à chaque fois :-)

Afin de facilement accéder à l’application, j’ai choisi de créer un VirtualHost apache :

/etc/apache2/sites-available/plum.local


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<VirtualHost *:80>
 ServerName www.plum.local
 DocumentRoot "/home/bastien/prog/php/plum/web"
 DirectoryIndex index.php
 <Directory "/home/bastien/prog/php/plum/web">
 AllowOverride All
 Allow from All
 </Directory>

 Alias /sf /home/bastien/prog/php/symfony-1.4.1/data/web/sf
 <Directory "/home/bastien/prog/php/symfony-1.4.1/data/web/sf">
 AllowOverride All
 Allow from All
 </Directory>
</VirtualHost>

En gros, on redirige www.plum.local (à ajouter dans /etc/hosts) vers le répertoire web/ de l’application, et on définit l’alias /sf qui pointe vers le répertoire data/sf/ du framework. Ce répertoire contient les CSS et images utilisées dans le code généré lors de la création du projet.

Voici à quoi ressemble l’application générée :

frontend_par_defaut

Nous n’avons pour l’instant généré qu’un projet vide pointant vers une page par défaut du framework. Nous corrigerons tout cela dans le second article, dans lequel nous définirons le modèle de données de notre application avant de tester la génération de code.

Bonux : comparaison des commandes grails et symfony

Génération du projet :


1
2
grails create-app ourapp
symfony generate:project ourapp

(Il faut par la suite générer une ou des application(s) avec symfony pour obtenir un résultat exploitable par le serveur web)

Accès au code source :

Le code source de cet article est disponible sur le projet googlecode d’Excilys à l’adresse : http://excilys.googlecode.com/svn/projects/plum/tags/plum_article_1/

La suite de la série est disponible ! Lire l’épisode 2.

Share
  1. Florent Bécart
    07/01/2010 à 18:29 | #1

    Je l’ai utilisé cet été. Bien que, d’un point de vue de développeur PHP, il soit plutôt complexe à appréhender (il faut compter quelques jours/semaines pour se familiariser avec la bête), les fonctionnalités sont très nombreuses (routing/ORM/déploiement…), très bien intégrées (la création d’un premier projet fonctionnel est très rapide) et la qualité globale du produit est excellente. De plus, comme tu l’as souligné, on trouve assez facilement de la documentation sur le net. Je le recommande sans hésitation !

  2. Pierre-Yves RICAU
    08/01/2010 à 09:32 | #2

    Les gens qui sont derrière ce framework savent regarder autour d’eux et tirer parti de ce qui se fait ailleurs :-) . Les contrôleurs sont au départ fortement inspirés de Struts 1, le YAML vient de perl, la ligne de commande et le scaffolding c’est RoR. A l’origine, il s’agit principalement d’un assemblage de divers frameworks Php (Propel, lime, etc) autour d’un ensemble structurant. Progressivement, la quasi intégralité du framework a été réécrit pour une plus grand cohérence, de meilleurs performances, et pour encore plus de productivité.

    A noter qu’il s’agit d’un framework orienté entreprise à 200%. Un soin très particulier est apporté aux notions de compatibilité ascendante, les procédures de migration sont très détaillées. Notez ainsi que la version 1.3 et 1.4 sont identiques en terme de fonctionnalités et de core, simplement la 1.3 supporte l’ancienne API et la nouvelle, alors que la 1.4 est destinée aux nouveaux projets qui souhaiteront par la suite évoluer vers symfony 2.0, et ne doivent pas utiliser l’ancienne API.

    Fait suffisamment rare pour être souligné, le framework est intégralement testé, que ce soit par des tests unitaires ou des tests d’intégration. Un composant n’est pas publié tant qu’il n’est pas entièrement testé.

    Vous trouverez aussi dans la documentation des chapitres très détaillés sur tout ce qui est mise en production, tuning des performances (aussi bien dans le code que dans la configuration du serveur), gestion des sources, outils de dev, méthodes de test…

  3. Bastien JANSEN
    08/01/2010 à 09:46 | #3

    Il est à noter que symfony lui-même est un fork du projet mojavi (http://www.mojavi.org/ ). Comme Pierre-Yves l’a dit, il a beaucoup évolué depuis. De nombreuses briques y sont parfaitement intégrées, mais il reste tout de même possible de les remplacer par d’autres.

    J’essayerai de détailler tout ça dans les prochains articles (mais PY tu viens de spoiler la moitié des choses intéressantes dont j’allais parler :) ).

  4. Pierre-Yves RICAU
    08/01/2010 à 11:40 | #4

    @Bastien
    Mes plus humbles excuses ! Mais je ne doute pas un instant que tu sauras compenser ce manque et nous présenter avec la même verve les aspects les plus intéressants de symfony ;-)

  5. arnaudweb
    11/01/2010 à 16:11 | #5

    Super article !! Grails puis Symfony !! Le blog Excilys existe depuis peu mais fait de la belle qualité.

    Je vous encourage à faire d’autres articles sur Symfony et sur PHP !!

  6. Bastien JANSEN
    11/01/2010 à 16:38 | #6

    @arnaudweb
    C’est prévu ! Le 2nd est en cours de relecture et le 3e en dév. intensif.
    Merci pour les encouragements, ça fait plaisir :)

  1. 15/01/2010 à 20:43 | #1
  2. 20/01/2010 à 00:07 | #2
  3. 10/02/2010 à 12:10 | #3