routage


De belles URL sont un must absolu pour toute application Web sérieuse. Cela signifie que les URL laides comme index.php?article_id=57 seront remplacées par /read/intro-to-symfony. index.php?article_id=57这类丑陋的URL要被/read/intro-to-symfony取代。

拥有灵活性是更加重要的。你将页面的URL从/blog改为/news时需要做些什么?你需要跟踪和更新多少链接以做出改变?如果你使用Symfony的路由,这就很容易了。

Symfony路由器允许你定义创造性的url,映射到应用程序的不同区域。在本章结束时,你将可以做到:

  • 创建复杂的路由,它们将映射到控制器

  • 在模板和控制器中生成URL

  • 从Bundle中(也可以从其它地方)加载路由资源

  • 对路由除错

路由样例 

一个路由,是指一个URL路径(path)到一个控制器(controller)的映射。例如,你想匹配一些URL:/blog/my-post/blog/all-about-symfony,并且发送路由到一个“能够查询和渲染那一篇博文”的控制器上。路由简单的很:

Annotations:// src/AppBundle/Controller/BlogController.phpnamespace AppBundle\Controller; use Symfony\Bundle\FrameworkBundle\Controller\Controller;use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route; class BlogController extends Controller{
    /**
     * @Route("/blog/{slug}", name="blog_show")
     */
    public function showAction($slug)
    {
        // ...
    }}
YAML:# app/config/routing.ymlblog_show:
    path:      /blog/{slug}
   defaults:  { _controller: AppBundle:Blog:show }
XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://symfony.com/schema/routing        http://symfony.com/schema/routing/routing-1.0.xsd">     <route id="blog_show" path="/blog/{slug}">
        <default key="_controller">AppBundle:Blog:show</default>
    </route></routes>
PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add('blog_show', new Route('/blog/{slug}', array(
    '_controller' => 'AppBundle:Blog:show',))); return $collection;

定义blog_show路由模式,用于匹配像/blog/*的URL,把相关参数或通配符用slug表示并传入。对于/blog/my-blog-post这样的URL,slug变量得到my-blog-post的值,并供你控制器使用。美观blog_show是一个内部名称,他没什么实际的意义就是一个唯一的标识。以后,你可用他来生成一些URL。

如果你不想去使用注释方式,因为你不喜欢他们,或者因为你不希望依赖于SensioFrameworkExtraBundle,你也可以使用YAML,XML或者PHP。在这些格式中,_controller参数是一个特殊的键,它告诉symfony路由指定的URL应该执行哪个控制器。_controller字符串称为逻辑名。它遵循规则指向一个特定的php类和方法,AppBundleControllerBlogController::showAction方法。

恭喜!你刚刚创建了一个路由并把它连接到控制器。现在,当你访问/blog/my-postshowAction控制器将被执行并且$slug变量就等于my-post

Avoir de la flexibilité est encore plus important. Que devez-vous faire pour changer l'URL d'une page de /blog à /news ? Combien de liens devez-vous suivre et mettre à jour pour apporter des modifications ? C'est facile si vous utilisez le routage de Symfony.

Symfony Router vous permet de définir des URL créatives qui correspondent à différentes zones de votre application. À la fin de ce chapitre, vous serez capable de : #🎜🎜#
  • #🎜🎜# Créer des itinéraires complexes qui seront mappés aux contrôleurs #🎜🎜#
  • #🎜🎜 # Générer des URL dans les modèles et les contrôleurs#🎜🎜#
  • #🎜🎜#Charger les ressources de routage à partir du Bundle (peut également provenir d'autres endroits)#🎜🎜#
  • #🎜 🎜#Débogage routage#🎜🎜#

Exemple de routage #🎜🎜# Une route fait référence au mappage d'un chemin URL (chemin) vers un contrôleur (contrôleur). Par exemple, vous souhaitez faire correspondre certaines URL : /blog/my-post et /blog/all-about-symfony, et envoyer une route vers un "can query and rendre ce billet de blog" sur le contrôleur. Le routage est très simple : #🎜🎜#
GET /blog/my-blog-post
YAML:# app/config/config.yml
framework:   
# ...
router: { resource: '%kernel.root_dir%/config/routing.yml' }
XML:<!-- app/config/config.xml --><?xml version="1.0" encoding="UTF-8" ?><container xmlns="http://symfony.com/schema/dic/services"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:framework="http://symfony.com/schema/dic/symfony"    xsi:schemaLocation="http://symfony.com/schema/dic/services        http://symfony.com/schema/dic/services/services-1.0.xsd        http://symfony.com/schema/dic/symfony        http://symfony.com/schema/dic/symfony/symfony-1.0.xsd">     <framework:config>
        <!-- ... -->
        <framework:router resource="%kernel.root_dir%/config/routing.xml" />
    </framework:config></container>
PHP:// app/config/config.php$container->loadFromExtension('framework', array(
   // ...    'router' => array(        'resource' => '%kernel.root_dir%/config/routing.php',    ),));
#🎜🎜#Définissez le modèle de routage blog_show, utilisé pour faire correspondre les URL comme /blog/*, et utilisez les paramètres pertinents ou les caractères génériques < code>slug représente et est transmis. Pour une URL telle que /blog/my-blog-post, la variable slug obtient la valeur de my-blog-post et la fournit à utilisation de votre contrôleur. Beautiful blog_show est un nom interne. Il n'a aucune signification pratique et n'est qu'un identifiant unique. Plus tard, vous pourrez l'utiliser pour générer des URL. #🎜🎜##🎜🎜#Si vous ne souhaitez pas utiliser d'annotations parce que vous ne les aimez pas, ou parce que vous ne voulez pas dépendre de SensioFrameworkExtraBundle, vous pouvez également utiliser YAML, XML ou PHP. Dans ces formats, le paramètre _controller est une clé spéciale qui indique à symfony quel contrôleur doit être exécuté pour l'URL spécifiée par la route. La chaîne _controller est appelée le nom logique. Il suit les règles et pointe vers une classe et une méthode PHP spécifiques, la méthode AppBundleControllerBlogController::showAction. #🎜🎜##🎜🎜#Félicitations ! Vous venez de créer un itinéraire et de le connecter au contrôleur. Désormais, lorsque vous visiterez /blog/my-post, le contrôleur showAction sera exécuté et la variable $slug sera égale à mon-poste. #🎜🎜##🎜🎜#Le but du routage Symfony : Mapper l'URL demandée au contrôleur. En suivant cet objectif, vous apprendrez diverses techniques qui simplifient le mappage des URL, même les plus complexes. #🎜🎜#

Routage : A y regarder de plus près

Lorsqu'une requête est envoyée à votre application, elle contient l'adresse "ressource" exacte de la demande du client. Cette adresse est appelée URL (ou URI), et elle peut être /contact, /blog/read-me ou toute autre chose. Voici un exemple de requête HTTP : /contact/blog/read-me或其它任何东西。下面是一个HTTP请求的例子:

Annotations:// src/AppBundle/Controller/MainController.php // ...class MainController extends Controller{
    /**
     * @Route("/")
     */
    public function homepageAction()
    {
        // ...
    }}

symfony路由系统的目的是解析url,并确定调用哪个控制器。整个过程是这样的:

  1. 由Symfony的前端控制器(如app.php)来处理请求。

  2. symfony的核心(Kernel内核)要求路由器来检查请求。

  3. 路由将输入的URL匹配到一个特定的路由,并返回路由信息,其中包括要执行的控制器信息。

  4. Symfony内核执行控制器并最终返回Response对象。

1466599518_84162_47822_request-flow-1.png

路由是将一个输入URL转换成特定的工具来执行控制器。

创建路由 

Symfony从一个单一的路由配置文件中加载所有的路由到你的应用程序。美观路由配置文件通常是app/config/routing.yml

YAML:# app/config/routing.yml_welcome:
    path:      /
    defaults:  { _controller: AppBundle:Main:homepage }

Le but du système de routage de symfony est d'analyser l'URL et de déterminer quel contrôleur appeler. L'ensemble du processus est le suivant :
  1. La requête est traitée par le contrôleur frontal de Symfony (tel que app.php).


  2. Le noyau de symfony (Kernel) nécessite que le routeur vérifie la requête.

La route fait correspondre l'URL d'entrée à une route spécifique et renvoie les informations sur la route, y compris les informations du contrôleur à exécuter.
  • 🎜Le noyau Symfony exécute le contrôleur et renvoie finalement l'objet Response. 🎜
  • 🎜1466599518_84162_47822_request -flow-1.png🎜🎜 Le routage convertit une URL d'entrée en un outil spécifique pour exécuter le contrôleur. 🎜🎜Créer des routes ¶🎜🎜🎜Symfony charge toutes les routes dans votre application à partir d'un seul fichier de configuration de routage. Le beau fichier de configuration de routage est généralement app/config/routing.yml, mais vous pouvez également placer le fichier n'importe où via le fichier de configuration de l'application (y compris les fichiers de configuration au format xml ou php). 🎜
    XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://symfony.com/schema/routing        http://symfony.com/schema/routing/routing-1.0.xsd">     <route id="_welcome" path="/">
            <default key="_controller">AppBundle:Main:homepage</default>
        </route> </routes>
    🎜🎜
    PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add('_welcome', new Route('/', array(
        '_controller' => 'AppBundle:Main:homepage',))); return $collection;
    Annotations:// src/AppBundle/Controller/BlogController.php // ...class BlogController extends Controller{
        /**
         * @Route("/blog/{slug}")
         */
        public function showAction($slug)
        {
            // ...
        }}
    🎜Bien que tous les itinéraires puissent être chargés à partir d'un fichier, il est courant d'inclure des ressources d'itinéraire supplémentaires. Pour ce faire, vous devez configurer le fichier de routage externe dans le fichier de routage principal. Pour des informations détaillées, veuillez consulter ce chapitre : Contient des ressources de routage externes. 🎜🎜🎜🎜

    Configuration de routage de base ¶

    Il est facile de définir un itinéraire, et une application typique devrait également avoir de nombreux itinéraires. Un itinéraire de base se compose de deux parties : path match et valeurs par défautArray :path 匹配和defaults数组:

    YAML:# app/config/routing.ymlblog_show:
        path:      /blog/{slug}
        defaults:  { _controller: AppBundle:Blog:show }
    XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://symfony.com/schema/routing        http://symfony.com/schema/routing/routing-1.0.xsd">     <route id="blog_show" path="/blog/{slug}">
            <default key="_controller">AppBundle:Blog:show</default>
        </route></routes>
    PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add('blog_show', new Route('/blog/{slug}', array(
        '_controller' => 'AppBundle:Blog:show',))); return $collection;
    Annotations:// src/AppBundle/Controller/BlogController.php // ...class BlogController extends Controller{
        /**
         * @Route("/blog/{page}", defaults={"page" = 1})
         */
        public function indexAction($page)
        {
            // ...
        }     /**
         * @Route("/blog/{slug}")
         */
        public function showAction($slug)
        {
            // ...
        }}

    该路由匹配首页(/)并将它映射到AppBundle:Main:homepage 控制器。_controller字符串被Symfony转换成PHP函数去执行。美观过程在本章(控制器命名模式)中被简短提及。

    带参数的路由 ¶

    路由系统支持很多有趣的路由写法。许多的路由都可以包含一个或者多个“参数或通配符”占位符:

    YAML:# app/config/routing.ymlblog:
        path:      /blog/{page}
        defaults:  { _controller: AppBundle:Blog:index, page: 1 }blog_show:
        path:      /blog/{slug}
        defaults:  { _controller: AppBundle:Blog:show }
    XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://symfony.com/schema/routing        http://symfony.com/schema/routing/routing-1.0.xsd">     <route id="blog" path="/blog/{page}">
            <default key="_controller">AppBundle:Blog:index</default>
            <default key="page">1</default>
        </route>     <route id="blog_show" path="/blog/{slug}">
            <default key="_controller">AppBundle:Blog:show</default>
        </route></routes>
    PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add('blog', new Route('/blog/{page}', array(
        '_controller' => 'AppBundle:Blog:index',
        'page'        => 1,))); $collection->add('blog_show', new Route('/blog/{show}', array(
        '_controller' => 'AppBundle:Blog:show',))); return $collection;
    Annotations:// src/AppBundle/Controller/ArticleController.php // ...class ArticleController extends Controller{
        /**
         * @Route(
         *     "/articles/{_locale}/{year}/{title}.{_format}",
         *     defaults={"_format": "html"},
         *     requirements={
         *         "_locale": "en|fr",
         *         "_format": "html|rss",
         *         "year": "\d+"
         *     }
         * )
         */
        public function showAction($_locale, $year, $title)
        {
        }}


    美观路径将匹配任何/blog/*的URL。更妙的是,美观{slug}占位符将自动匹配到控制器中。换句话说,如果该URL是/blog/hello-world,控制器中$slug变量的值就是hello-world。这可以用来,匹配博客文章标题的字符串。

    然而这种方式路由将不会匹配/blog这样的URL,因为默认情况下,所有的占位符都是必填的。当然这也是可以变通的,可以在defaults数组中添加占位符(参数)的值来实现。

    添加{通配符}的条件 

    快速浏览一下已经创建的路由:

    YAML:# app/config/routing.ymlarticle_show:
      path:     /articles/{_locale}/{year}/{title}.{_format}
      defaults: { _controller: AppBundle:Article:show, _format: html }
      requirements:
          _locale:  en|fr
          _format:  html|rss
          year:     \d+
    XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://symfony.com/schema/routing        http://symfony.com/schema/routing/routing-1.0.xsd">     <route id="article_show"        path="/articles/{_locale}/{year}/{title}.{_format}">         <default key="_controller">AppBundle:Article:show</default>
            <default key="_format">html</default>
            <requirement key="_locale">en|fr</requirement>
            <requirement key="_format">html|rss</requirement>
            <requirement key="year">\d+</requirement>     </route></routes>
    PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add(
        'article_show',
        new Route('/articles/{_locale}/{year}/{title}.{_format}', array(
            '_controller' => 'AppBundle:Article:show',
            '_format'     => 'html',
        ), array(
            '_locale' => 'en|fr',
            '_format' => 'html|rss',
            'year'    => '\d+',
        ))); return $collection;
    // src/AppBundle/Controller/BlogController.phpnamespace AppBundle\Controller; use Symfony\Bundle\FrameworkBundle\Controller\Controller; class BlogController extends Controller{
        public function showAction($slug)
        {
            // ...
        }}


    你能发现问题吗?两个路由都匹配类似/blog/*的URL。Symfony路由总是选择它第一个匹配的(blog)路由。换句话说,该blog_show路由永远被匹配。相反,像一个/blog/my-blog-post的URL会匹配第一个(blog)路由,并返回一个my-blog-post的值给{page}参数。

    Routage avec paramètres ¶

    Le système de routage prend en charge de nombreuses façons intéressantes d'écrire des itinéraires. De nombreuses routes peuvent contenir un ou plusieurs espaces réservés "paramètre ou caractère générique" :

    var url = Routing.generate(
        'blog_show',
        {"slug": 'my-blog-post'});
    $this->get('router')->generate('blog', array(
        'page' => 2,
        'category' => 'Symfony'));// /blog/2?category=Symfony
    Twig:<a href="{{ path('blog_show', {'slug': 'my-blog-post'}) }}">
      Read this blog post.
    </a>
    php:<a href="<?php echo $view['router']->path('blog_show', array(
        'slug' => 'my-blog-post',)) ?>">
        Read this blog post.
    </a>


    Les jolis chemins correspondront à n'importe quelle URL /blog/* . Mieux encore, de superbes espaces réservés {slug} seront automatiquement adaptés au contrôleur. En d'autres termes, si l'URL est /blog/hello-world, la valeur de la variable $slug dans le contrôleur est hello-world . Cela peut être utilisé pour faire correspondre les chaînes dans les titres des articles de blog.

    Cependant, le routage de cette manière ne correspondra pas aux URL telles que /blog, car par défaut, tous les espaces réservés sont requis. Bien entendu, cela peut également être modifié en ajoutant des valeurs d'espace réservé (paramètre) au tableau defaults.

    Ajouter des conditions {wildcard}

    Parcourir rapidement l'itinéraire créé :< /p>

    use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
     $this->generateUrl('blog_show', array('slug' => 'my-blog-post'), UrlGeneratorInterface::ABSOLUTE_URL);
    // http://www.example.com/blog/my-blog-post
    Twig:<a href="{{ url('blog_show', {'slug': 'my-blog-post'}) }}">
      Read this blog post.
    </a>
    php:<a href="<?php echo $view['router']->url('blog_show', array(
        'slug' => 'my-blog-post',)) ?>">
        Read this blog post.
    </a>

    当生成一个绝对URL链接时,所使用的主机自动检测当前使用的Request对象。当生成从web环境外的绝对URL(例如一个控制台命令)这是行不通的。请参见 如何从控制台生成URL 来学习如何解决这个问题。



    Pouvez-vous repérer le problème ? Les deux itinéraires correspondent à des URL telles que /blog/*. Le routage Symfony choisit toujours la première route (blog) correspondante à laquelle elle correspond. En d'autres termes, la route blog_show sera toujours mise en correspondance. En revanche, une URL comme /blog/my-blog-post correspondra à la première route (blog) et renverra un my-blog-post< La valeur de /code> est donné au paramètre {page}.

    URLRouteParameters
    /blog/2blog_list$page = 2
    /blog/my-blog-postblog_show$slug = my-blog-post
    public function showAction($slug){
      // ...}
    $params = $this->get('router')->match('/blog/my-blog-post');
    // array(
    //     'slug'        => 'my-blog-post',
    //  '_controller' => 'AppBundle:Blog:show',
    // ) 
    $uri = $this->get('router')->generate('blog_show', array(
      'slug' => 'my-blog-post'));
    // /blog/my-blog-post
    class MainController extends Controller{
        public function showAction($slug)
        {
            // ...         $url = $this->generateUrl(
                'blog_show',
                array('slug' => 'my-blog-post')
            );
        }}
    $url = $this->container->get('router')->generate(
        'blog_show',
        array('slug' => 'my-blog-post'));

    Cet itinéraire correspond à la page d'accueil ( / ) et le mappe au contrôleur AppBundle:Main:homepage. La chaîne _controller est convertie par Symfony en fonction PHP pour exécution. Le processus esthétique est brièvement mentionné dans ce chapitre (Modèles de dénomination des contrôleurs).

    URL RouteParamètres
    /blog/2
    blog_list#🎜🎜#$page = 2#🎜🎜##🎜🎜#/blog/ mon-blog-post#🎜🎜#blog_show#🎜🎜#$slug = mon-article-de-blog#🎜🎜##🎜🎜##🎜🎜##🎜🎜#

    Donnez à {wildcard} une valeur par défaut

    Exemple de routage avancé

    Dans Symfony, vous pouvez réaliser tout ce dont vous avez besoin en créant une structure de routage puissante. Voici un exemple pour montrer à quel point le système de routage est flexible :

    rrreeerrreeerrreeerrreee

    Comme vous pouvez le constater, un beau routage ne correspond qu'à une partie de l'URL qui satisfait à {_locale} comme (fr ou fr) et {year> sont numériques. Cet itinéraire vous montre également que vous pouvez utiliser un point pour séparer deux espaces réservés. L'URL correspondant à l'itinéraire ci-dessus est la suivante :
    {_locale}为(en或者fr)和 {year}是数字的。该路由还向你展示了你可以使用一个句号来分割两个占位符。上面路由匹配的URL如下:

    • /articles/en/2010/my-post

    • /articles/fr/2010/my-post.rss

    • /articles/en/2013/my-latest-post.html

    特殊的_format路由参数

    这个示例也突显了特殊的_format路由参数。当使用这个参数时,匹配值将成为Request对象的“request format”(请求格式)。

    最终,请求格式被用在“设置响应的Content-Type”这种地方(如一个json请求格式将转换成application/jsonContent-Type)。它也可以在控制器中使用,根据不同的_format值去渲染不同的模板。_format参数是一种非常强大的方式,把相同的内容以不同格式来渲染(译注:即输出)。

    在symfony3.0之前的版本中,可以覆写request(对象)中的格式参数(_format),通过添加名为“_format”的query参数即可(例:/foo/bar?_format=json

    • /articles/en/2010/my-post
  • < code>/articles /fr/2010/my-post.rss
  • /articles/en/2013/my-latest-post.html

    < /li>< /ul>

    Paramètre spécial de route _format
    🎜Cet exemple met également en évidence le paramètre spécial de route _format. Lorsque ce paramètre est utilisé, la valeur correspondante devient le "format de requête" de l'objet Request. 🎜🎜En fin de compte, le format de requête est utilisé à des endroits comme "définir la réponse Content-Type" (par exemple, un format de requête json sera converti en application /json< /code>'s Content-Type). Il peut également être utilisé dans les contrôleurs pour restituer différents modèles basés sur différentes valeurs _format. Le paramètre _format est un moyen très puissant de restituer le même contenu dans différents formats. 🎜🎜Dans les versions antérieures à symfony3.0, vous pouvez remplacer le paramètre de format (_format) dans la requête (objet) en ajoutant un paramètre de requête nommé "_format" C'est tout ( par exemple : /foo/bar?_format=json). L'abus de ce comportement est considéré comme une mauvaise pratique et rendra la mise à niveau de votre programme vers symfony3 "extrêmement compliquée". 🎜🎜🎜🎜🎜🎜Parfois, vous souhaitez rendre certaines parties de votre routage « configuration globale ». Symfony peut le faire en utilisant les paramètres du conteneur de services. Consultez Comment utiliser les paramètres du conteneur de services dans le routage pour en savoir plus. 🎜🎜🎜

    Paramètres d'itinéraire spéciaux ¶

    Comme vous pouvez le voir, chaque paramètre d'itinéraire ou valeur par défaut peut être utilisé comme paramètre de la méthode du contrôleur. De plus, trois paramètres sont spéciaux : Chacun ajoute une fonctionnalité unique à votre application :

    • _controller
    • _controller
    • 正如你所看到的,这个参数是用来决定“当路由匹配时”要执行哪个控制器的。
    • _format
    • 用于设置请求格式(request format。了解详情)。
    • _locale
    • 用于设置请求的locale (了解详情).

    控制器命名模式 

    如果你使用YAML,XML或PHP的路由配置,那么每个路由都必须有一个_controller参数,用于指示当路匹配时应执行哪个控制器。这个参数使用一个简单的字符串pattern,叫做控制器逻辑名(logical controller name),Symfony用它来映射一个特定的PHP方法或类。此pattern有三个部分,用冒号隔开:

    bundle:controller:action

    假设,一个_controller值是一个AppBundle:Blog:show那么意味着:

    _format permet de définir le format de la requête (format de la requête. En savoir plus). _locale
    BundleController ClassMethod Name
    AppBundleBlogControllershowAction Comme vous pouvez le voir, ce paramètre est utilisé pour déterminer quel contrôleur sera exécuté "quand l'itinéraire correspond".
    est utilisé pour définir les paramètres régionaux demandés (en savoir plus).
  • Modèle de dénomination du contrôleur < a href="#catalog9" class="headerlink" id="catalog9">¶

    🎜Si vous utilisez une configuration de routage YAML, XML ou PHP, alors chaque route doit avoir un _controller< Paramètre /code>, utilisé pour indiquer quel contrôleur doit être exécuté lorsque le chemin correspond. Ce paramètre utilise un modèle de chaîne simple appelé nom du contrôleur logique, que Symfony utilise pour mapper une méthode ou une classe PHP spécifique. Ce modèle comporte trois parties, séparées par des deux-points : 🎜
    🎜bundle:controller:action🎜
    🎜Supposons qu'une valeur _controller est un AppBundle:Blog:show signifie alors : 🎜🎜
    BundleClasse de contrôleurNom de la méthode
    AppBundle🎜BlogController🎜showAction 🎜🎜🎜🎜

    Le contrôleur pourrait ressembler à ceci :

    rrreee

    Notez que Symfony a ajouté la chaîne Controller comme nom de classe sur Blog (Blog= > BlogController), ajoutez la chaîne Action comme nom de méthode (show=>showAction). Blog上添加了字符串Controller作为类名(Blog=>BlogController),添加字符串Action作为方法名(show=>showAction)。

    你也可以使用它的FQCN类名及方法来指定这个类:AppBundleControllerBlogController::showAction。但如果你遵循一些简单的命名约定,逻辑名将更加简洁也更加灵活。

    除了使用逻辑名和FQCN类名之外,Symfony也支持第三种指定控制器的方式。这种方式只使用一个冒号分隔(如service_name:indexAction),并将控制器作为一个服务来引用(参见如何把控制器定义为服务)。

    路由参数和控制器参数 ¶

    路由参数(如{slug}是非常重要的,因为它(们)都被用作控制器方法的参数:

    rrreee

    现实中,defaults集将参数值一起合并成一个表单数组。该数组中的每个键都被做为控制器的参数。

    换句话说,对于控制器方法的每个参数,Symfony2都会根据该名称来查找路由参数,并将其值指向到控制器作为参数。在上面的高级示例当中,下列变量的任何组合(以任意方式)都被用作showAction()方法的参数:

    • $_locale

    • $year

    • $title

    • $_format

    • $_controller

    • $_route

    占位符和defaults集被合并在一起,就就算是$_controller变量也是可用的。更多细节的讨论,请参见作为 控制器–把路由参数传入控制器。

    你也可以使用指定的$_route

    Vous pouvez également spécifier cette classe en utilisant son nom de classe FQCN et sa méthode : AppBundleControllerBlogController::showAction. Mais si vous suivez quelques conventions de dénomination simples, les noms logiques seront plus simples et plus flexibles.
    En plus d'utiliser des noms logiques et des noms de classe FQCN, Symfony prend également en charge une troisième façon de spécifier les contrôleurs. Cette approche utilise uniquement un délimiteur deux-points (tel que service_name:indexAction) et référence le contrôleur en tant que service (voir Comment définir un contrôleur en tant que service). 🎜🎜🎜

    Paramètres de route et paramètres du contrôleur ¶

    🎜Les paramètres de route (tels que {slug}) sont très importants car ils (ils) sont utilisés comme méthodes de contrôleur Paramètres : 🎜rrreee 🎜En réalité, l'ensemble defaults combine les valeurs des paramètres dans un tableau de formulaire. Chaque clé du tableau est utilisée comme paramètre du contrôleur. , Symfony2 recherchera le paramètre de route en fonction de ce nom et pointera sa valeur vers le contrôleur en tant que paramètre. Dans l'exemple avancé ci-dessus, toute combinaison des variables suivantes (de quelque manière que ce soit est utilisée comme paramètres du ). Méthode showAction() : 🎜
    • 🎜$_locale🎜
    • 🎜$year🎜
    • 🎜$title 🎜
    • 🎜 $_format🎜
    • 🎜$_controller🎜
    • 🎜$_route🎜
    🎜 espace réservé et L'ensemble des valeurs par défaut est fusionné, et même la variable $_controller est disponible. Voir En tant que contrôleur – Passer des paramètres de route aux contrôleurs pour plus de détails 🎜< div class="admonition-wrapper" id="">
    🎜Vous pouvez également utiliser la variable $_route spécifiée, dont la valeur est le nom de la route correspondante. 🎜🎜🎜

    Vous pouvez même définir des informations complémentaires dans vos itinéraires et y accéder dans vos contrôleurs. Pour plus d'informations, lisez Comment transmettre des informations supplémentaires des routes aux contrôleurs

    Génération d'URL ¶

    Le système de routage est également utilisé pour générer des URL. En réalité, le routage est un système bidirectionnel : mappage des URL aux contrôleurs + paramètres et mappage des routes + paramètres aux URL. Les méthodes match() et generate() forment ce système bidirectionnel. En utilisant l'exemple précédent de blog_show : match()generate()方法构成了这个双向系统。使用之前的blog_show的例子:

    rrreee

    要生成一个URL,你需要指定路由的名称(如blog_show)以及任意的通配符(如slug = my-blog-post)。有个这些信息,任何URL就可以很容易的生成了:

    rrreee

    在控制器中你没有继承symfony的父类Controller,那么你不可以使用generateUrl()快捷方法,但你可以使用router的generate()服务方法:

    rrreee

    在即将到来的部分中,你将学会如何在模板中生成URL地址。

    如果你的应用程序前端使用的是ajax请求,你可能希望根据你的路由配置,在JavaScript中生成URL。通过使用FOSJsRoutingBundle,你就可以做到:

    rrreee

    更多信息请阅读这个bundle文档。

    生成带有Query Strings的URL 

    这个generate方法采用通配符数组来生成URL。但是如果在其中添加了额外的键值对,他们将会被添加成Query Strings来生成一个新的URL:

    rrreee

    在模板里生成URL 

    在应用程序页面之间进行连接时,最常见的地方就是从模板中生成URL。这样做其实和以前一样,但是使用的是一个模板助手函数:

    rrreeerrreee

    生成绝对的URL 

    默认情况下,路由器会产生相对的URL(如/blog)。在控制器中,很简单的把generateUrl()方法的第三参数设置成UrlGeneratorInterface::ABSOLUTE_URL即可。

    rrreee

    在模板引擎Twig中,要使用url()函数(生成一个绝对的URL),而不是path()rrreee

    Pour générer une URL, vous devez spécifier le nom de l'itinéraire (tel que blog_show) et tout caractères génériques (tels que slug = my-blog-post). Avec ces informations, n'importe quelle URL peut être facilement générée :

    rrreee

    Dans le contrôleur, si vous n'héritez pas de la classe parent symfony Controller, alors vous ne pouvez pas utiliser generateUrl ()< /code>, mais vous pouvez utiliser la méthode de service generate() du routeur :

    rrreee

    Dans la section suivante, vous apprendrez comment générer une URL adresses dans les modèles.

    Si le front-end de votre application utilise des requêtes ajax, vous souhaiterez peut-être générer l'URL en JavaScript en fonction de votre configuration de routage. En utilisant le FOSJsRoutingBundle, vous pouvez faire :

    rrreee

    Veuillez lire ce document bundle pour plus d'informations.

    Générer une URL avec des chaînes de requête

    #🎜🎜# Le < La méthode code>generate utilise un tableau de caractères génériques pour générer l'URL. Mais si des paires clé-valeur supplémentaires y sont ajoutées, elles seront ajoutées en tant que chaînes de requête pour générer une nouvelle URL : #🎜🎜#rrreee

    Générer l'URL dans le modèle

    #🎜🎜#L'endroit le plus courant pour se connecter entre les pages d'application est de générer des URL à partir de modèles. Faire cela est en fait la même chose qu'avant, mais en utilisant une fonction d'assistance de modèle : #🎜🎜#rrreeerrreee

    Générer une URL absolue

    #🎜🎜#Par défaut, le routeur générera des URL relatives (telles que /blog). Dans le contrôleur, il est très simple de définir le troisième paramètre de la méthode generateUrl() sur UrlGeneratorInterface::ABSOLUTE_URL. #🎜🎜#rrreee#🎜🎜#Dans le moteur de template Twig, utilisez la fonction url() (pour générer une URL absolue) au lieu de la fonction path() ( générer une URL relative). En php, vous devez passer UrlGeneratorInterface::ABSOLUTE_URL:#🎜🎜#rrreeerrreeerrreee#🎜🎜#Summary ¶#🎜🎜##🎜🎜#Routing est une URL qui mappe la requête entrante à l'utilisateur Le système de fonctions du contrôleur à traiter la demande. Il vous permet de spécifier une belle URL et de « découpler » les fonctionnalités de l'application de l'URL. Le routage est un mécanisme bidirectionnel, ce qui signifie qu'il peut également être utilisé pour générer des URL. #🎜🎜##🎜🎜#Continuez ! ¶#🎜🎜##🎜🎜#Route, vérifiée ! Maintenant, allez débloquer l’alimentation du contrôleur. #🎜🎜##🎜🎜#