La nouvelle version du célèbre
framework Symfony est maintenant disponible en version finale. Elle avait été annoncée il y a maintenant plus d’un an lors du Symfony Live 2010. Et ce fut au mois de mars dernier, lors du Symfony Live 2011 à San Francisco (puis plus tard à Paris) que fut annoncée l’arrivée prochaine de Symfony2. Finalement, avec plusieurs mois de retard, la version finale est maintenant disponible. Ce retard fût en partie dû à l'important succès de Symfony2 auprès de la communauté qui s'est énormément investie en retournant tous les bug rencontrés, en allant jusqu'à proposer de nombreuses idées d'améliorations. De plus, les producteurs de Symfony2 souhaitaient fournir au public une version tout à fait stable et éviter l'arrivée de version telle que 2.0.1 apportant des correctifs de bug (comme c'est le cas avec de nombreux logiciels). Finalement, après 12
Preview Release, 5
BETA et 6
Release Candidate, la version finale qui nous sort s'annonce d'une grande stabilité et donc déjà prête pour la mise en production.
Présentation du framework
Logo de Symfony2
Symfony2 est un
framework open-source réalisé intégralement en PHP, soutenu et développé par
SensioLabs, une société française. Il fournit une architecture et des outils facilitant et accélérant le développement d'applications orientées web, tout en intégrant automatiquement la gestion de la sécurité. Comme la plupart des
framework web, il est basé sur l’architecture
MVC.
Cette version marque un vrai tournant dans l’histoire de Symfony. On peut d’ailleurs noter que
Symfony2 prend une majuscule alors que les précédentes versions n’en avaient pas : on parlait alors de
symfony 1.x.x.
Un nouveau site a aussi été construit :
Symfony.com. Il rassemble pour le moment une documentation très complète et assez facile à comprendre, même si vous n’avez jamais utilisé de
framework auparavant. Cette facilité de prise en main constitue l'un des points forts du projet.
Symfony2, un nouveau départ
Pour Symfony2, Fabien Potencier (créateur et développeur principal de Symfony) a annoncé être reparti de zéro. Autant symfony 1.x se rapprochait du modèle lancé par
Ruby-on-Rails ; autant Symfony2 a été totalement repensé pour être le plus extensible possible, et par conséquent, pour faciliter la vie des développeurs. Le
framework a choisi de se rapprocher au maximum des standards du web (des conventions), notamment en se rapprochant du fonctionnement HTTP, permettant ainsi de très grosses performances.
L’architecture des dossiers a été revue (et simplifiée) par rapport à la branche 1.x. L’utilisateur n’a maintenant plus que 4 dossiers (au lieu des 7 dossiers nécessaires à symfony 1.x) :
- app : ce dossier contient tous les fichiers nécessaires à la configuration de l’application ;
- src : ce dossier contient toutes les sources du projet (les contrôleurs, les vues, les entités du modèle - voir plus bas, les formulaires, etc.) ;
- vendor : ce dossier contient toutes les bibliothèques (Symfony compris) utilisées par l'application ;
- web : ce dossier est le seul accessible par les utilisateurs finaux (les clients web).
Le cœur de Symfony2 a été réalisé en utilisant les nouveautés de PHP 5.3.2, permettant ainsi l’utilisation des puissants
namespaces. Ce dernier ne compte qu’un peu plus d’une centaine de lignes de code, ce qui nous montre la simplicité de cette version.
Symfony2 est aussi prévu pour être distribuée en plusieurs versions.
En effet, avec symfony 1.x, il n’y avait qu’une version téléchargeable qu’il fallait ensuite configurer en fonction de son projet. Il existait aussi une « sandbox » qui était prévue pour faire découvrir Symfony et le tester. Or, les développeurs de Symfony se sont aperçus que beaucoup de personnes commençaient un projet avec la sandbox, car elle était déjà configurée et prête à l’emploi. Symfony2 sera donc disponible en plusieurs versions :
- la version sandbox, uniquement pour la découverte du framework ;
- la version classique, qui fournit le framework brut, sans aucune configuration ;
- la version « Standard Edition », qui fournit le framework prêt à l’emploi, configurée pour la plupart des cas d’utilisation ;
- la version CMF, qui fournira un CMF s’appuyant sur Symfony2 ;
- et peut-être bien d’autres versions...
Vous pouvez dès à présent
télécharger la version « Standard Edition ».
Les « Bundles » font leur arrivée
Symfony2 est entièrement basé sur le
pattern de l'
injecteur de dépendances et introduit la notion de
Bundles. Les Bundles sont en fait des bouts de code pouvant fonctionner indépendamment, mais pouvant aussi interagir avec d’autres Bundles (grâce à l’injection de dépendances). Chaque Bundle va pouvoir executer ou gérer une fonction bien précise de l'application. Cela permet de mieux structurer un site web.
Par exemple, imaginons pour le Site du Zéro :
- un Bundle général, qui accueille les visiteurs ;
- un Bundle pour la gestion des news ;
- un Bundle pour la gestion des forums ;
- un Bundle pour la gestion des tutoriels ;
- etc.
Un autre intérêt de ces Bundles est de permettre à la communauté de les partager. Par exemple, il existe déjà un Bundle Forum, un Bundle pour administrer le site, un autre pour la gestion d’un espace membre, etc. Chacun de ces Bundles peut facilement être intégré à un projet Symfony2. La communauté étant particulièrement active, il existe déjà un site web regroupant tout ce travail :
symfony2bundles.org.
Si le
core de Symfony2 est si petit, c’est parce que Symfony2 est lui-même bâti autour de Bundle. La gestion des formulaires en est remise à un Bundle par exemple ; celle de la base de données aussi (via un ORM par exemple) ; et même la gestion des contrôleurs est effectuée par un Bundle.
En savoir plus sur les Bundles
Doctrine 2, l'ORM par défaut
Doctrine 2 est un ORM très puissant qui permet de fournir au développeur une couche d’abstraction de la base de données. Plutôt que de penser en tables et en enregistrements (ou lignes), on pense « orienté objet » : une table devient une classe, un enregistrement devient une instanciation de cette classe. Doctrine 2 appelle ces classes des entités. Plus besoin donc de passer par PhpMyAdmin pour créer ces tables sous MySQL par exemple. Il suffit de créer une classe avec des attributs, et Doctrine 2 se charge du reste.
Image extraite de la documentation officielle de Symfony2
Voici un exemple d'entité inspiré par la documentation officielle de Symfony2 :
Secret (cliquez pour afficher)Code : PHP - src/Acme/StoreBundle/Entity/Product.php 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93 | <?php
namespace Acme\StoreBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Entity
* @ORM\Table(name="product")
*/
class Product
{
/**
* @ORM\Id
* @ORM\Column(type="integer")
* @ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* @ORM\Column(type="string", length="100")
*/
protected $name;
/**
* @ORM\Column(type="decimal", scale="2")
*/
protected $price;
/**
* @ORM\Column(type="text")
*/
protected $description;
public function __construct($name = NULL, $price = NULL, $description = NULL)
{
if ($name !== NULL)
$this->setName($name);
if ($price !== NULL)
$this->setPrice($price);
if ($description !== NULL)
$this->setDescription($description);
}
public function getId()
{
return $this->id;
}
public function getName()
{
return $this->name;
}
public function setName($name)
{
$this->name = $name;
}
public function getPrice()
{
return $this->price;
}
public function setPrice($price)
{
// On se sert des getter pour appliquer des vérifications plus pointues
$this->name = floatval($price);
}
public function getDescription()
{
return $this->description;
}
public function setDescription($description)
{
$this->description = $description;
}
}
|
Et voici comment utiliser cette entité à partir d'un contrôleur :
Secret (cliquez pour afficher)Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | <?php
use Acme\StoreBundle\Entity;
$product_1 = new Product();
$product_1->setName("Bike");
$product_1->setPrice(800);
$product_1->setDescription("fixed gear, blue, fast");
$product_2 = new Product("Helmet", 20.99, "black, fits most");
$product_3 = new Product("Jersey", 50.15);
$product_3->setPrice(35);
$product_3->setDescription("women's small, green and white");
$em = $this->getDoctrine()->getEntityManager();
$em->persist($product_1);
$em->persist($product_2);
$em->persist($product_3);
$em->flush();
|
À la fin de ce code, nous retrouvons la base de donnée dessinée sur l'image ci-dessus.
Le Bundle Doctrine 2 est fourni par défaut dans Symfony2.
En savoir plus sur Doctrine 2
Twig, un moteur de template puissant
Logo de Twig
On note aussi l'intégration de
Twig, un moteur de template très prometteur. On remarque que les développeurs se sont inspirés de très bons
framework tels que Spring (JAVA) ou Django (Python). Pour ceux qui ont déjà fait du développement en Python avec Django, on remarque que la syntaxe de Twig est assez semblable à Django. Son utilisation est facultative. Un
tutoriel à ce sujet est disponible depuis peu sur le site.
En savoir plus sur Twig dans Symfony2
Le framework de formulaire
Symfony2 intègre par défaut un composant qui s'occupe de gérer les formulaires. Ce « micro-framework » permet la création de formulaires très facilement sans avoir à écrire une seule ligne de html. Il suffit pour cela de créer une classe Formulaire. Voici un exemple inspiré de la documentation officielle :
Code : PHP - src/Acme/StoreBundle/Form/ProductType.php 1
2
3
4
5
6
7
8
9
10
11
12
13
14 | <?php
namespace Acme\StoreBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
class ProductType extends AbstractType
{
public function buildForm(FormBuilder $builder, array $options)
{
$builder->add('name');
$builder->add('price', 'money', array('currency' => 'USD'));
}
}
|
Twig permet un rendu très facile du formulaire dans vos
templates :
Code : PHP - Template Twig | <form action="{{ path('store_product') }}" method="post" {{ form_enctype(form) }}>
{{ form_widget(form) }}
<input type="submit" />
</form>
|
Mais si vous souhaitez personnaliser au maximum vos rendus, vous pouvez utiliser ce genre de
template :
Code : PHP - Template Twig 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | <form action="{{ path('store_product') }}" method="post" {{ form_enctype(form) }}>
{{ form_errors(form) }}
<div>
{{ form_label(form.name) }}
{{ form_errors(form.name) }}
{{ form_widget(form.name) }}
</div>
<div>
{{ form_label(form.price) }}
{{ form_errors(form.price) }}
{{ form_widget(form.price) }}
</div>
{{ form_rest(form) }}
<input type="submit" />
</form>
|
Bien sûr, dans la réalité, on utilisera une boucle pour afficher tous les champs plutôt que de faire un par un les blocs <div></div>.
Finalement, la validation des données envoyées par l'utilisateur se fait grâce à un second composant (aussi intégré par défaut) qui vérifie si tous les champs obligatoires sont bien remplis et si toutes les informations envoyées sont valides.
En savoir plus sur les formulaires dans Symfony2
Des configurations très simples
L’utilisation de fichiers de configuration est très importante pour un framework. Cela permet de pouvoir s’adapter à tous les besoins des développeurs. On peut par exemple y configurer le comportement général du site (environnement en mode développement, mode test ou mode production), le
Routing du site (
En savoir plus sur le Routing), ou encore la gestion de la sécurité. Les fichiers de configuration peuvent utiliser plusieurs types de scripts :
YAML,
XML ou PHP. En général, YAML est préféré, car il est beaucoup moins verbeux que ses deux confrères. Vous pouvez bien entendu utiliser les trois types de scripts en même temps.
Symfony2, une performance accrue
Symfony2 est un framework très rapide, et cela parce qu’il utilise un système de cache très puissant : le cache HTTP. De plus Doctrine 2 utilise lui-même un système de mise en cache pour les résultats des requêtes, ce qui permet de soulager le serveur gérant la base de données.
En savoir plus sur le cache HTTP.
Liens et sources
Site officiel de Symfony
Tutoriel sur Symfony2 sur le Site du Zéro
Trouvez une formation
Précédente
Suggestions
Flux RSS News
Twitter
Facebook
Google+
90 Participations
Connectez-vous !
Connectez-vous !
Revenir à la liste des news
Lire aussi