Aller au menu - Aller au contenu

Icône Mon premier Hello World avec Symfony2

Avatar
Par Avatar Alexandre Bacco (winzou)
Mise à jour : 02/05/2012
Difficulté : Difficile Difficile Creative Commons BY-NC-SA
20 752 visites depuis 7 jours, dont 1 031 sur ce chapitre classé 17/786
L'objectif de ce chapitre est de créer de toute pièce notre première page avec Symfony2 : une simple page blanche comprenant un « Hello World! ». Nous allons donc créer tous les éléments indispensables pour concevoir une telle page.

Nous allons donc avoir une vue d'ensemble de tous les acteurs qui interviennent dans la création d'une page : routeur, contrôleur et template. Pour cela, tous les détails ne seront pas expliqués afin de se concentrer sur l'essentiel : la façon dont ils se coordonnent. Vous devrez attendre les prochains chapitre pour étudier un à un ces trois acteurs, patience donc !

Ne bloquez donc pas sur un point si vous ne comprenez pas tout, forcez-vous juste à comprendre l'ensemble. À la fin du chapitre, vous aurez une vision globale de la création d'une page et l'objectif sera atteint.

Bonne lecture !
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Créons notre route

Nous travaillons dans notre bundle SdzBlogBundle, placez vous donc dans son répertoire : src/Sdz/BlogBundle.

Pour créer une page, il faut d'abord définir l'URL à laquelle elle sera accessible. Pour cela, il faut créer la route de cette page.

Le routeur (ou « router ») ? Une route ?


Objectif


L'objectif du routeur est de dire à Symfony2 ce qu'il doit faire lorsque que l'on appelle l'URL /hello-world (par exemple). Nous devons donc créer une route qui va dire : « lorsque l'on est sur l'URL /hello-world, alors on appelle le contrôleur « Blog » qui va afficher un Hello World. ».

Voici un schéma de l'interaction Noyau - Routeur - Route :
Image utilisateur


Comme je l'ai dit, nous ne toucherons ni au noyau, ni au routeur : nous nous occuperons juste des routes. Ouf, voilà du travail en moins. :p

1. Créons notre fichier de routes


Les routes se définissent dans un simple fichier texte, que Symfony2 a déjà généré. Usuellement, on nomme ce fichier Resources/config/routing.yml dans le répertoire du bundle. Ouvrez le fichier, et rajoutez cette route à la suite de celle qui existe déjà :
Code : Autre
1
2
3

HelloTheWorld:
    pattern:  /hello-world
    defaults: { _controller: SdzBlogBundle:Blog:index }

Vous venez de créer votre première route !

Contrairement à ce que vous pourriez penser, l'indentation se fait avec 4 espaces par niveau, pas avec des tabulations ! Je le précise en grand ici parce qu'un jour vous ferez l'erreur (l'inévitable ne peut être évité), et vous me remercierez de vous avoir mis sur la voie :p Et ceci est valable pour tous vos fichiers .yml

Attention également, il semble y avoir des erreurs lors des copier-coller depuis le tutoriel vers les fichiers .yml. Si vous rencontrez une erreur, pensez à bien définir l'encodage du fichier en "UTF-8 sans BOM" et à supprimer les éventuels caractères non désirés. C'est un bogue étrange qui provient du site, mais dont on ne connait pas l'origine.


Essayons de comprendre rapidement ce fichier :
  • Le "HelloTheWorld" est le nom de la route. Il est assez arbitraire, et vous permet juste de vous y retrouver par la suite ;
  • Le "pattern" correspond à l'URL à laquelle nous souhaitons que notre hello world soit accessible. C'est ce qui permet à la route de dire : « cette URL est pour moi, je prends » ;
  • Le "_controller" correspond à l'action que l'on veut exécuter et au contrôleur que l'on va appeler (un contrôleur peut contenir plusieurs actions, c'est à dire plusieurs pages).

Ne vous inquiétez pas, un chapitre complet est dédié au routeur et vous permettra de jouer avec. Pour l'instant ce fichier nous permet juste d'avancer.
Mais avant d'aller plus loin, penchons-nous sur la valeur que l'on a donnée à _controller : « SdzBlogBundle:Blog:index ». Cette valeur se découpe en suivant les pointillés les deux-points (« : ») :
  • « SdzBlogBundle » est le nom de notre bundle, celui dans lequel Symfony2 ira chercher le contrôleur ;
  • « Blog » est le nom du contrôleur à ouvrir. En terme de fichier, cela correspond à controller/BlogController.php dans le répertoire du bundle. Dans notre cas, nous avons src/Sdz/BlogBundle/controller/BlogController.php comme chemin absolu.
  • « index » est le nom de la méthode à exécuter au sein du contrôleur.


2. Informons Symfony2 que nous avons des routes pour lui


On l'a vu précédemment, grâce au bon travail du générateur, Symfony2 est déjà au courant du fichier de routes de notre bundle. Mais sachez que ce n'est pas par magie !

Il faut que vous sachiez comment tout cela s'imbrique. Ouvrez le fichier de configuration globale de notre application : app/config/config.yml. Dans ce fichier, il y a plein de valeurs, mais la ligne qui nous intéresse pour le routeur est la ligne 10 :
Code : Autre
1

router:          { resource: "%kernel.root_dir%/config/routing.yml" }

Cette ligne indique au routeur qu'il doit chercher les routes dans le fichier app/config/routing.yml (%kernel.root_dir% est un paramètre qui vaut "app" dans notre cas). Le routeur va donc se contenter d'ouvrir ce fichier. Ouvrez-le également. Outre les commentaires, vous voyez que le générateur a inséré une route spéciale qui va importer le fichier de route de notre bundle.

C'est parce que ce fichier était vide (avant la génération du bundle) que l'on avait une erreur « page introuvable » en mode « prod » : comme il n'y a aucune route définie, Symfony2 nous informe à juste titre qu'aucune page n'existe.
Pour information, si le mode « dev » ne nous donnait pas d'erreur, c'est parce que le mode « dev » charge le fichier routing_dev.yml et non routing.yml. Et dans ce fichier, allez voir, il y a bien quelques routes définies. ;) Et il y a aussi la ligne qui importe le fichier routing.yml, afin d'avoir les routes du mode « prod » dans le mode « dev » (l'inverse étant bien sûr faux).


Bref, vous n'avez rien à modifier ici, c'était juste pour que vous sachiez que l'import du fichier de routes d'un bundle n'est pas automatique, il se définit dans le fichier de routes global.

Revenons à nos moutons. En fait, on aurait pu ajouter notre route directement dans ce fichier routing.yml. Cela aurait fonctionné et cela aurait été plutôt rapide. Mais c'est oublier notre découpage en bundles ! En effet, cette route concerne le bundle du blog, elle doit donc se trouver dans notre bundle et pas ailleurs. N'oubliez jamais ce principe.

Cela permet à notre bundle d'être indépendant : si plus tard nous ajoutons, modifions ou supprimons des routes dans notre bundle, nous ne toucherons qu'au fichier src/Sdz/BlogBundle/Resources/config/routing.yml au lieu de app/config/routing.yml. ;)

Et voilà, il n'y a plus qu'à créer le fameux contrôleur Blog ainsi que sa méthode index !
Retour en haut

Créons notre contrôleur

Le rôle du contrôleur


Rappelez-vous ce que nous avons dit sur le MVC :
  • le contrôleur est la « glu » de notre site ;
  • il « utilise » tous les autres composants (base de données, formulaires, templates, etc.) pour générer la réponse suite à notre requête ;
  • c'est ici que résidera toute la logique de notre site : si l'utilisateur est connecté et qu'il a le droit de modifier cet article, alors j'affiche le formulaire d'édition des articles de mon blog.


Créons notre contrôleur


1. Le fichier de notre contrôleur « Blog »


Dans un bundle, les contrôleurs se trouvent dans le répertoire Controller du bundle.
Rappelez-vous : dans la route, on a dit qu'il fallait faire appel au contrôleur nommé « Blog ». Les fichiers des contrôleurs doivent respecter une convention très simple : leur nom doit commencer par le nom du contrôleur, ici « Blog », suivi du suffixe « Controller ». Au final, on doit donc créer le fichier src/Sdz/BlogBundle/Controller/BlogController.php.

Même si Symfony2 a déjà créé un contrôleur pour nous, ce n'est qu'un exemple, on va utiliser le notre. Ouvrez donc notre BlogController.php et collez-y le code suivant :
Code : PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
<?php

namespace Sdz\BlogBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;

class BlogController extends Controller
{
    public function indexAction()
    {
        return new Response("Hello World !");
    }
}

Surprise : allez voir sur http://localhost/Symfony/web/app_dev.php/hello-world ! Même bundle mais contrôleur différent, on en fait des choses !

Maintenant, essayons de comprendre rapidement ce fichier :
  • ligne 3 : on se place dans le namespace des contrôleurs de notre bundle. Rien de bien compliqué, suivez la structure des répertoires dans lequel se trouve le contrôleur ;
  • ligne 5 : notre contrôleur hérite de ce contrôleur de base. Il faut donc le charger grâce au « use » ;
  • ligne 6 : notre contrôleur va utiliser l'objet Response, il faut donc le charger grâce au « use » ;
  • ligne 8 : le nom de notre contrôleur respecte le nom du fichier pour que l'autoload fonctionne ;
  • ligne 10 : on définit la méthode indexAction(). N'oubliez pas de mettre le suffixe « Action » derrière le nom de la méthode ;
  • ligne 12 : on crée une réponse toute simple. L'argument de l'objet Response est le contenu de la page que vous envoyez au visiteur, ici « Hello World ! ». Puis on retourne cet objet.

Bon : certes, le rendu n'est pas très joli, mais au moins, nous avons atteint l'objectif d'afficher nous-mêmes un Hello World.

Pourquoi indexAction() ? J'ai pas suivi là.

En effet il faut savoir que le nom des méthodes des contrôleurs doivent respecter une convention. Lorsque dans la route on parle de l'action "index", dans le contrôleur on doit définir la méthode indexAction(), c'est-à-dire le nom de l'action suivi du suffixe "Action", tout simplement. Il n'y a pas tellement à réfléchir, c'est une simple convention pour distinguer les méthodes qui vont être appelées par le noyau (les xxxAction()) des autres méthodes que vous pourriez créer.

Mais écrire le contenu de sa page de cette manière dans le contrôleur, ça n'est pas très pratique, et en plus de cela, on ne respecte pas le modèle MVC. Utilisons donc les templates !
Retour en haut

Créons notre template Twig

Les templates avec Twig


Savez-vous ce qu'est un moteur de template ?
C'est un script qui permet d'utiliser des templates, c'est-à-dire des fichiers qui ont pour but d'afficher le contenu de votre page HTML de façon dynamique, mais sans PHP. Comment ? Avec leur langage à eux. Chaque moteur a son propre langage.

Avec Symfony2, nous allons employer le moteur Twig. Voici un exemple de comparaison entre un template simple en PHP et un template en « langage Twig ».

PHP :
Code : PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<!DOCTYPE html>
<html>
    <head>
        <title>Welcome to Symfony!</title>
    </head>
    <body>
        <h1><?php echo $page_title ?></h1>

        <ul id="navigation">
            <?php foreach ($navigation as $item): ?>
                <li>
                    <a href="<?php echo $item->getHref() ?>"><?php echo $item->getCaption() ?></a>
                </li>
            <?php endforeach; ?>
        </ul>
    </body>
</html>

Et ce même template, mais avec Twig :
Code : HTML & Django
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
<!DOCTYPE html>
<html>
    <head>
        <title>Welcome to Symfony!</title>
    </head>
    <body>
        <h1>{{ page_title }}</h1>

        <ul id="navigation">
            {% for item in navigation %}
                <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
            {% endfor %}
        </ul>
    </body>
</html>


Ils se ressemblent, soyons d'accord. Mais celui réalisé avec Twig est bien plus facile à lire ! Pour afficher une variable, vous faites juste {{ ma_var }} au lieu de <?php echo $ma_var ?>.

Le but en fait est de faciliter le travail de votre designer. Un designer ne connaît pas forcément le PHP, ni forcément Twig d'ailleurs. Mais Twig est très rapide à prendre en main, plus rapide à écrire et à lire, et il dispose aussi de fonctionnalités très intéressantes. Par exemple, imaginons que votre designer veuille mettre les titres en lettres majuscules (COMME CECI). Il lui suffit de faire : {{ titre|upper }}, où « titre » est la variable qui contient le titre d'un article de blog par exemple. C'est plus joli que <?php echo strtoupper($titre) ?>, vous êtes d'accord ?

Nous verrons dans le chapitre dédié à Twig les nombreuses fonctionnalités que le moteur vous propose et qui vont vous faciliter la vie. En attendant, nous devons avancer sur notre « Hello World ! ».

Utiliser Twig avec Symfony2


Comment utiliser un template Twig depuis notre contrôleur, au lieu d'afficher notre texte tout simple ?

1. Créons le fichier du template


Le répertoire des templates (ou vues) d'un bundle se trouve dans le dossier Resources/views. Ici encore on ne va pas utiliser le template généré par Symfony2. Appelons notre template Blog/index.html.twig et mettons-le dans le répertoire des vues. Nous avons donc le fichier src/Sdz/BlogBundle/Resources/views/Blog/index.html.twig.

Blog/index.html.twig ? Découpons ce nom :
  • Blog/ est le nom du répertoire. Nous l'avons appelé comme notre contrôleur afin de nous y retrouver (ce n'est pas une obligation, mais c'est fortement recommandé) ;
  • index est le nom de notre template qui est aussi le nom de la méthode de notre contrôleur (idem, pas obligatoire, mais recommandé) ;
  • html correspond au format du contenu de notre template. Ici, nous allons y mettre du code HTML, mais vous serez amené à vouloir y mettre du XML ou autre : vous changerez donc cette extension. Cela permet de mieux s'y retrouver ;
  • twig est le format de notre template. Ici, nous utilisons Twig comme moteur de template, mais il est toujours possible d'utiliser des templates PHP.

Revenez à notre template et copiez-collez ce code à l'intérieur :
Code : HTML
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
<!DOCTYPE html>
<html>
    <head>
        <title>Bienvenue sur ma première page avec le Site du Zéro !</title>
    </head>
    <body>
        <h1>Hello World !</h1>

        <p>
            Le Hello World est un grand classique en programmation.
            Il signifie énormément, car cela veut dire que vous avez
            réussi à exécuter le programme pour accomplir une tâche simple :
            afficher ce hello world !
        </p>
    </body>
</html>

Dans ce template, nous n'avons utilisé ni variable, ni structure Twig. En fait, c'est un simple fichier contenant du code HTML pur !

2. Appelons ce template depuis le contrôleur


Il ne reste plus qu'à appeler ce template. C'est le rôle du contrôleur, c'est donc au sein de la méthode indexAction() que nous allons appeler le template. Cela se fait très simplement avec la méthode <?php $this->render(). Cette méthode prend en paramètre le nom du template et retourne un objet de type Response avec pour contenu le contenu de notre template. Voici le contrôleur modifié en conséquence :
Code : PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
<?php

namespace Sdz\BlogBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;

class BlogController extends Controller
{
    public function indexAction()
    {
        return $this->render('SdzBlogBundle:Blog:index.html.twig');
    }
}

Nous n'avons modifié que la ligne 12. La convention pour le nom du template est la même que pour le nom du contrôleur, souvenez-vous : NomDuBundle:NomDuContrôleur:NomDeLAction.

Maintenant, retournez sur la page http://localhost/Symfony/web/app_dev.php/hello-world et profitez !

Notez également l'apparition de la toolbar en bas de la page. Je vous l'avais déjà dit, Symfony2 l'ajoute automatiquement lorsqu'il détecte la balise fermante </body>. C'est pour cela que nous ne l'avions pas tout à l'heure avec notre « Hello World » tout simple. ;)

Voulez-vous vous amuser un peu avec les variables Twig ?
  • Modifiez la ligne 12 du contrôleur pour rajouter un 2e argument à la méthode render() : <?php return $this->render('SdzBlogBundle:Blog:index.html.twig', array('nom' => 'winzou'));.
  • Modifiez votre template en remplaçant <h1>Hello World !</h1> par <h1>Hello {{ nom }} !</h1>.
  • C'est tout ! Rechargez la page. Bonjour à vous également. :)
Retour en haut

Notre objectif : créer un blog

Le fil conducteur : un blog


Tout au long de ce cours, nous construirons un blog.
Cela me permet d'utiliser des exemples cohérents entre eux et de vous montrer comment construire un blog de toutes pièces. Bien sûr, libre à vous d'adapter les exemples au projet que vous souhaitez mener, je vous y encourage, même !

Le choix du blog n'est pas très original, mais il permet que l'on se comprenne bien : vous savez déjà ce qu'est un blog, vous comprendrez donc, en théorie, tous les exemples. ;)

Notre blog


Le blog que nous allons créer est très simple. En voici les grandes lignes :
  • nous aurons des articles auxquels nous attacherons des tags ;
  • nous pourrons lire, écrire, éditer et rechercher des articles ;
  • nous pourrons créer, modifier et supprimer des tags ;
  • au début, nous n'aurons pas de système de gestion des utilisateurs : nous devrons saisir notre nom lorsque nous rédigerons un article. Puis nous rajouterons la couche utilisateur ;
  • au début, il n'y aura pas de système de commentaires. Puis nous ajouterons cette couche commentaire.


Un peu de nettoyage


Avec tous les éléments générés par Symfony2 et les nôtres, il y a un peu de redondance. Vous pouvez donc supprimer joyeusement :
  • Le contrôleur Controller/DefaultController.php;
  • Les vues dans le répertoire Resources/views/Default;
  • La route SdzBlogBundle_homepage dans Resources/config/routing.yml.

Schéma de développement sous Symfony2


Rafraîchissez la page pour vérifier que tout est bon... raté ! En effet il faut prendre dès maintenant un réflexe Symfony2 : vider le cache. Car Symfony, pour nous offrir autant de fonctionnalités et être si rapide, utilise beaucoup son cache (des calculs qu'il ne fait qu'une fois puis qu'il stocke). Deux cas de figure :
  • En mode prod, c'est simple, Symfony2 ne vide jamais le cache. Ca lui permet de ne faire aucune vérification sur la validité du cache, et de servir les pages très rapidement à vos visiteurs. La solution : vider le cache à la main à chaque fois que vous faites des changements. Cela se fait grâce à la commande php app/console cache:clear --env=prod.
  • En mode dev, c'est plus simple et plus compliqué. Lorsque vous modifiez votre code, Symfony reconstruit une bonne partie du cache à la prochaine page que vous chargez. Donc pas forcément besoin de vider le cache. Seulement, comme il ne reconstruit pas tout, il peut apparaître des bugs parfois, comme l'erreur filemtime que vous avez là. Dans ce cas, un petit php app/console cache:clear résout le problème en 3 secondes !

Parfois, il se peut que la commande cache:clear génère des erreurs lors de son exécution. Dans ce cas, essayez de relancer la commande, des fois une deuxième passe peut résoudre les problèmes. Dans le cas contraire, supprimez le cache à la main en supprimant simplement le répertoire app/cache/dev (ou app/cache/prod suivant l’environnement).

Typiquement, un schéma classique de développement est le suivant :
  • Je fais des changements, je teste ;
  • Je fais des changements, je teste ;
  • Je fais des changements, je teste ça ne marche pas, je vide le cache ça marche ;
  • Je fais des changements, je teste ;
  • Je fais des changements, je teste ;
  • Je fais des changements, je teste ça ne marche pas, je vide le cache ça marche ;
  • ...
  • En fin de journée, j'envoie tout sur le serveur de production, je vide obligatoirement le cache, je teste, ça marche.

Évidemment, quand je dis "je teste ça ne marche pas", j'entends "ça devrait marcher et l'erreur rencontrée est étrange". Si vous faites une erreur dans votre propre code, c'est pas un cache:clear qui va la résoudre ! :p


Et maintenant, c'est parti !
Retour en haut
Et voilà, nous avons créé une page de A à Z ! Voici plusieurs remarques sur ce chapitre.

D'abord, ne vous affolez pas si vous n'avez pas tout compris. Le but de ce chapitre était de vous donner une vision globale d'une page Symfony2. Vous avez des notions de bundles, de routes, de contrôleurs et de templates : vous savez presque tout ! Il ne reste plus qu'à approfondir chacune de ces notions, ce que nous ferons dès le prochain chapitre.

Le code tel qu'il doit être à la fin de ce chapitre est ici : https://github.com/winzou/SdzBlog/tree [...] 8e4d07dab93cf Vous pouvez y jeter un oeil si vous n'êtes pas sûr de ce que vous avez fait ;)

Ensuite, sachez que tout n'est pas à refaire lorsque vous créez une deuxième page. Je vous invite là, maintenant, à créer une page /byebye-world et voyez si vous y arrivez. Dans le cas contraire relisez ce chapitre, puis si vous ne trouvez pas votre erreur, n'hésitez pas à poser votre question sur le forum PHP, d'autres Zéros qui sont passés par là seront ravis de vous aider. :)

Sur le forum, pensez à mettre le tag [Symfony2] dans le titre de votre sujet, afin de s'y retrouver. :)

Enfin, préparez-vous pour la suite, les choses sérieuses commencent !
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
73 commentaires pour "Mon premier Hello World avec Symfony2"
Note moyenne : 3.75 / 4 (245 votes)
Pseudo Commentaire
Hors ligne sclabet # Posté le 03/03/2012 à 04:06:31
Avatar

Avis : Très bon

Très bien expliqué, et avec humour.
merci beaucoup.
Hors ligne molinadiaz # Posté le 07/03/2012 à 22:11:53

Avis : Très bon

Merci winzou ! Je ne suis clairement pas déçu de tes tutoriels jusqu'à maintenant ! Je cours voir la suite en espérant qu'elle soit aussi bien rédigée :)

Je me pose une question :

Citation : winzou
Rafraîchissez la page pour vérifier que tout est bon... raté ! En effet il faut prendre dès maintenant un réflexe Symfony2 : vider le cache.

Après avoir fait le nettoyage, j'ai rafraîchi et cela fonctionnait toujours sans avoir vidé le cache. Coup de chance ? :euh:

D'avance merci pour tes éclaircissements ;)
En stage à San Diego, CA. De fin janvier à mi-avril ! Enjoy my blog!
 
Hors ligne wilfried2006 # Posté le 14/03/2012 à 22:47:57

Avis : Bon

Concernant la debugbarr , dans mon cas elle est absente lorsque je suis en /app_dev.php/, la seule fois que je la vois c'est lorsque je lance la page de config de la database: monsite/web/app_dev.php/. si vous pouvez m'eclairer..??
Hors ligne ko_ok70 # Posté le 19/03/2012 à 15:25:31
@silence
Avatar

Avis : Très bon

Citation : LutinRose
Fais bien attention d'avoir mis des espaces et non des tabulations dans le fichier routing.yml situé dans app/config. Si tu a copié/collé le code, il y a sûrement une tabulation au lieu de tes espaces. :p
J'avais ce problème.
Par contre, lorsque je tente d'aller à http://localhost/Symfony/web/app_dev.php/hello-world j'ai ce message d'erreur :
Unable to find the controller for path "/hello-world". Maybe you forgot to add the matching route in your routing configuration?

Mais si je rentre l'url http://localhost/Symfony/web/app_dev.php/hello/world tout fonctionne.

Pourquoi ? :D

Edit : j'ai trouvé la solution. Lorsque l'on crée notre route, plutôt que de copier/coller le code pour aller plus vite, il faut le taper à la main pour que cela fonctionne correctement. J'espère que ça sera utile à d'autre personnes. :D

Oui ça fait partie des Problèmes courants rencontrés:
Problèmes de non-chargement de fichier routing.yml
Cette remarque n'est à prendre en compte que si vous utilisez le langage Yaml pour vos routes. Comme ce langage est très susceptible, il ne faut sous aucune raison copier-coller du code Yaml. C'est la meilleure façon pour que Symfony2 vous sorte plein d'erreurs !Nekland
Autre remarque :
vérifier que le fichier routing.yml est encoder en ANSI
Mes yeux de Coleur # :D ;)
 
Hors ligne Arkad # Posté le 12/04/2012 à 18:50:12
Avatar

Ville : Liège
Pays : Belgique

 Bonjour,

Citation : molinadiaz
Je me pose une question :

Citation : winzou
Rafraîchissez la page pour vérifier que tout est bon... raté ! En effet il faut prendre dès maintenant un réflexe Symfony2 : vider le cache.

Après avoir fait le nettoyage, j'ai rafraîchi et cela fonctionnait toujours sans avoir vidé le cache. Coup de chance ?


Même chose chez moi, mais j'ai quand même exécuté la commande cache:clear après.

Ce tutoriel est très plaisant à suivre et bien détaillé, j'ai pu installer et configurer avec succès Symfony sous Ubuntu 11.10 et Windows XP. Merci winzou.

Voir tous les commentaires