Avant de commencer, vous devez créer un bundle. Dans Symfony2, un bundle est comme un plugin, excepté le fait que tout le code de votre application siégera dans un bundle.
Un bundle n'est rien d'autre qu'un répertoire qui contient tout ce qui est relatif à une fonctionnalité spécifique, ce qui inclut les classes PHP, la configuration et même les feuilles de style et le javascript (voir Le Système de Bundles).
Afin de créer un bundle nommé AcmeHelloBundle (un bundle fictif que vous créerez dans ce chapitre), lancez la commande suivante et suivez les instructions affichées à l'écran (choisissez les options par défaut) :
1 $ php app/console generate:bundle --namespace=Acme/HelloBundle --format=yml
Un répertoire src/Acme/HelloBundle est créé pour le bundle. Une ligne est aussi automatiquement ajoutée au fichier app/AppKernel.php afin que le bundle soit correctement enregistré:
1 2 3 4 5 6 7 8 9 10 11 // app/AppKernel.php
public function registerBundles() { $bundles = array( // ... new Acme\HelloBundle\AcmeHelloBundle(), ); // ... return $bundles; }
Maintenant que votre bundle est mis en place, vous pouvez commencer à construire votre application à l'intérieur du bundle.
Etape 1 : Créez la Route
Dans une application Symfony2, le fichier de configuration des routes se trouve par défaut dans app/ config/routing.yml. Comme toute configuration dans Symfony2, vous pouvez également choisir d'utiliser des fichiers XML ou PHP afin de configurer vos routes.
Si vous regardez le fichier de routage principal, vous verrez que Symfony a déjà ajouté une entrée lorsque vous avez généré le AcmeHelloBundle :
1. http://httpd.apache.org/docs/2.0/mod/mod_dir.html 2. http://wiki.nginx.org/HttpCoreModule#location
Listing 4-5 Listing 4-6 Listing 4-7 1 2 3 4 # app/config/routing.yml acme_hello: resource: "@AcmeHelloBundle/Resources/config/routing.yml" prefix: /
Ce code est très basique : il dit à Symfony de charger la configuration de routage depuis le fichier Resources/config/routing.yml qui se trouve dans le AcmeHelloBundle. Cela signifie que vous pouvez placer votre configuration de routage directement dans le fichier app/config/routing.yml ou organiser vos routes dans votre application et les importer depuis ce fichier.
Maintenant que le fichier routing.yml du bundle est importé, ajoutez la nouvelle route qui définit l'URL de la page que vous êtes sur le point de créer :
1 2 3 4 # src/Acme/HelloBundle/Resources/config/routing.yml hello: pattern: /hello/{name}
defaults: { _controller: AcmeHelloBundle:Hello:index }
Le routage est constitué de deux parties principales : le pattern, qui est l'URL correspondante à cette route, et un tableau par défaut, qui spécifie le contrôleur qui devra être exécuté. La syntaxe pour le paramètre dans le pattern ({name}) est un joker. Cela signifie que hello/Ryan, hello/Bernard ou n'importe quelle URL similaire correspondra à cette route. Le paramètre {name} sera également passé à notre contrôleur afin que nous puissions utiliser la valeur afin de saluer l'utilisateur.
Le système de routage dispose de beaucoup d'autres fonctionnalités qui vous permettront de créer des structures d'URL puissantes et flexibles dans votre application. Pour plus de détails, lisez le chapitre dédié aux routes Routing.
Etape 2 : Créez le Contrôleur
Quand une URL comme /hello/Ryan est traitée par l'application, la route hello est reconnue et le contrôleur AcmeHelloBundle:Hello/index est exécuté par le framework. L'étape suivante est de créer ce contrôleur.
Le contrôleur - AcmeHelloBundle:Hello:index est le nom logique du contrôleur, et il est associé à la méthode indexAction d'une classe PHP appelée Acme\HelloBundle\Controller\HelloController. Commencez par créer ce fichier dans votre AcmeHelloBundle :
1 2 3 4 5 6 // src/Acme/HelloBundle/Controller/HelloController.php namespace Acme\HelloBundle\Controller; class HelloController { }
En réalité, un contrôleur n'est rien d'autre qu'une méthode PHP que vous créez et que Symfony exécute. C'est à cet endroit que le code propre à l'application utilisera les informations de la requête afin de construire et préparer la ressource demandée par la requête. Excepté dans certaines situations avancées, le résultat final d'un contrôleur sera toujours le même : un objet Response Symfony2.
Créez la méthode indexAction que Symfony exécutera lorsque la route hello sera identifiée : 1
2
// src/Acme/HelloBundle/Controller/HelloController.php namespace Acme\HelloBundle\Controller;
Listing 4-8 Listing 4-9 Listing 4-10 Listing 4-11 3 4 5 6 7 8 9 10 11 12 use Symfony\Component\HttpFoundation\Response; class HelloController {
public function indexAction($name) {
return new Response('<html><body>Hello '.$name.'!</body></html>'); }
}
Le contrôleur est simple : il crée un nouvel objet Response qui a pour premier argument le contenu qui doit être utilisé dans la réponse (une petite page HTML dans notre cas).
Félicitations ! Après avoir n'avoir créé qu'une route et un contrôleur, vous avez une page pleinement fonctionnelle ! Si vous avez tout effectué correctement, votre application devrait vous saluer:
1 http://localhost/app_dev.php/hello/Ryan
Vous pouvez aussi voir votre application en environnement de « prod » en allant à l'adresse : 1 http://localhost/app.php/hello/Ryan
Si vous avez une erreur, c'est certainement parce que vous avez besoin de vider votre cache grâce à la commande :
1 $ php app/console cache:clear --env=prod --no-debug
Une troisième étape optionnelle dans ce processus est de créer un template.
Les contrôleurs sont le point central de votre code et un élément clé de la création de pages. Pour plus d'informations lisez le chapitre Chapitre Contrôleurs.
Étape 3 facultative : Créez le Template
Les templates vous permettent de déplacer toute la présentation (ex: code HTML) dans un fichier séparé et de réutiliser différentes portions d'un layout. A la place d'écrire le code HTML dans le contrôleur, retournez plutôt un template :
1 2 3 4 5 6 7 8 9 10 11 12 // src/Acme/HelloBundle/Controller/HelloController.php namespace Acme\HelloBundle\Controller; use Symfony\Bundle\FrameworkBundle\Controller\Controller; class HelloController extends Controller
{
public function indexAction($name) {
return $this->render('AcmeHelloBundle:Hello:index.html.twig', array('name' => $name));
Listing 4-12 Listing 4-13 13 14 15 16
// render a PHP template instead
// return $this->render('AcmeHelloBundle:Hello:index.html.php', array('name' => $name));
} }
Afin d'utiliser la méthode render()3, votre contrôleur doit étendre la classe SymfonyBundleFrameworkBundleControllerController` (API docs: Controller4), qui ajoute des raccourcis pour des tâches fréquemment utilisées dans les contrôleurs. Dans l'exemple ci-dessus, c'est ce qui est fait en ajoutant la ligne use et en étendant la classe Controller à la ligne 6. La méthode render() crée un objet Response qui contient le contenu d'un template rendu. Comme tout autre contrôleur, vous retournerez cet objet Response.
Notez qu'il y a deux différents exemples afin de rendre un template. Par défaut, Symfony2 supporte deux langages différents de templates : les templates classiques PHP et les simples, mais puissants templates Twig. Ne paniquez pas, vous êtes libres de choisir celui que vous désirez voire les deux.
Le contrôleur rend le template AcmeHelloBundle:Hello:index.html.twig, qui suit la convention de nommage :
NomBundle:NomContrôleur:NomTemplate
C'est le nom logique du template, qui est associé à une location physique selon la convention suivante. /chemin/vers/NomBundle/Resources/views/NomContrôleur/NomTemplate
Dans ce cas, AcmeHelloBundle est le nom de bundle, Hello est le nom du contrôleur et enfin index.html.twig est le template :
1 2 3 4 5 6 {# src/Acme/HelloBundle/Resources/views/Hello/index.html.twig #} {% extends '::base.html.twig' %} {% block body %} Hello {{ name }}! {% endblock %}
Analysons maintenant le template Twig ligne par ligne :
• Ligne 2 : Le symbole extends définit un template parent. Le template définit explicitement un fichier layout dans lequel il sera inséré.
• Ligne 4 : Le symbole block indique que tout ce qui est à l'intérieur doit être placé à l'intérieur d'un bloc appelé body. Comme vous le voyez, c'est en définitive la responsabilité du template parent (base.html.twig) de rendre le bloc body.
Le nom de fichier du template parent, ::base.html.twig, est dispensé des portions NomBundle et NomContrôleur (remarquez les deux points (::) au début). Ceci signifie que le template se situe en dehors du bundle et dans le répertoire app.
1 2
{# app/Resources/views/base.html.twig #} <!DOCTYPE html>
Listing 4-14 3 4 5 6 7 8 9 10 11 12 13 14 <html> <head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>{% block title %}Welcome!{% endblock %}</title>
{% block stylesheets %}{% endblock %}
<link rel="shortcut icon" href="{{ asset('favicon.ico') }}" /> </head>
<body>
{% block body %}{% endblock %} {% block javascripts %}{% endblock %}
</body> </html>
Le fichier du template de base définit le layout HTML en rend le bloc body que vous avez défini dans le template index.html.twig. Il rend également un bloc title, que vous pouvez choisir de définir dans le template index.html.twig. Si vous ne définissez pas le bloc title dans le template enfant, il aura pour valeur par défaut Welcome!.
Les templates sont une façon puissante de rendre et d'organiser le contenu de votre page. Les templates peuvent tout rendre, des layouts HTML aux codes CSS, ou n'importe quoi d'autre que le contrôleur peut avoir besoin de retourner à l'utilisateur.
Dans le cycle de vie d'une requête, le template est un outil facultatif. Souvenez vous que le but de chaque contrôleur est de renvoyer un objet Response. Le moteur de templates est un outil puissant, bien qu'optionnel, pour créer le contenu de cet objet Response.