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-post
,showAction
控制器将被执行并且$slug
变量就等于my-post
/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 ¶ h2>#🎜🎜# 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,并确定调用哪个控制器。整个过程是这样的:
由Symfony的前端控制器(如
app.php
)来处理请求。symfony的核心(Kernel内核)要求路由器来检查请求。
路由将输入的URL匹配到一个特定的路由,并返回路由信息,其中包括要执行的控制器信息。
Symfony内核执行控制器并最终返回
Response
对象。
路由是将一个输入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 :
- La requête est traitée par le contrôleur frontal de Symfony (tel queLa 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.
app.php
).
Le noyau de symfony (Kernel) nécessite que le routeur vérifie la requête.
Response
. 🎜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éfaut
Array :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}
参数。
URL | Route | Parameters | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
/blog/2 | blog_list | $page = 2 | ||||||||||||
/blog/my-blog-post | blog_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 ( | Routage avec paramètres ¶
URL | Route | Paramètres |
---|---|---|
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 :
rrreeerrreeerrreeerrreeeComme vous pouvez le constater, un beau routage ne correspond qu'à une partie de l'URL qui satisfait à {_locale}
comme (fr code> 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
/articles/en/2013/my-latest-post.html
< /li>< /ul>
Paramètre spécial de route _format_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
_locale
控制器命名模式 ¶
如果你使用YAML,XML或PHP的路由配置,那么每个路由都必须有一个_controller
参数,用于指示当路匹配时应执行哪个控制器。这个参数使用一个简单的字符串pattern,叫做控制器逻辑名(logical controller name),Symfony用它来映射一个特定的PHP方法或类。此pattern有三个部分,用冒号隔开:
bundle:controller:action
假设,一个_controller
值是一个AppBundle:Blog:show
那么意味着:
Bundle | Controller Class | Method Name |
---|---|---|
AppBundle | BlogController | showAction Comme vous pouvez le voir, ce paramètre est utilisé pour déterminer quel contrôleur sera exécuté "quand l'itinéraire correspond". |
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 : 🎜Bundle Classe de contrôleur Nom de la méthode 🎜AppBundle
🎜BlogController
🎜showAction code>🎜🎜🎜🎜Le contrôleur pourrait ressembler à ceci :
rrreeeNotez 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 : #🎜🎜#rrreeeGé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 : #🎜🎜#rrreeerrreeeGénérer une URL absolue ¶ a >
#🎜🎜#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. #🎜🎜##🎜🎜#