Detaillierte Erläuterung des Systemroutings von Symfony2-Studiennotizen

In diesem Artikel wird das Systemrouting von Symfony2 ausführlich beschrieben. Teilen Sie es wie folgt mit allen als Referenz:

Schöne URLs sind für eine seriöse Webanwendung unbedingt erforderlich. Auf diese Weise werden hässliche URLs wie index.php?article_id=57 ausgeblendet und durch beliebtere ersetzt /read/intro-to-symfony.

Flexibilität ist noch wichtiger. Was ist, wenn Sie die URL einer Seite ändern möchten, beispielsweise von /blog in /new?

Wie viele Links müssen Sie finden und aktualisieren? Wenn Sie den Router von Symfony verwenden, ist dieser Wechsel einfach.

Mit dem Symfony2-Router können Sie kreativere URLs definieren und verschiedene Bereiche Ihrer Anwendung zuordnen.

Erstellen Sie komplexe Routen, die Controllern zugeordnet sind, und generieren Sie URLs in Vorlagen und Controllern.

Laden Sie Routing-Ressourcen aus Bundles (oder anderswo)

Debuggen Sie Ihre Routen

Routing-Aktivität

Ein Pfad ist eine Bindung von einem URL-Muster an einen Controller.

Angenommen, Sie möchten einen beliebigen Pfad wie /blog/my-post oder /blog/all-about-symfony abgleichen und an einen Controller senden, wo dieser nach der Blog-Entität suchen und sie rendern kann.

Der Pfad ist einfach:

YAML-Format:

# app/config/routing.yml
blog_show:
pattern: /blog/{slug}
defaults: {_controller: AcmeBlogBundle:Blog:show }

XML-Format:

<!-- 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" pattern="/blog/{slug}">
<default key="_controller">AcmeBlogBundle:Blog:show</default>
</route>
</routes>

PHP-Codeformat:

// app/config/routing.php
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog_show', new Route('/blog/{slug}', array(
     '_controller' => 'AcmeBlogBundle:Blog:show',
)));

blog_show path definiert ein URL-Muster, das wie folgt aussieht /blog/* Der Platzhalter heißt hier Slug. Für die URL/blog/my-blog-post erhält die Slug-Variable den Wert my-blog-post. Der Parameter
_controller ist ein spezifischer Schlüssel, der Symfogy mitteilt, welcher Controller ausgeführt wird, wenn eine URL mit diesem Pfad übereinstimmt. Die Zeichenfolge
_controller wird als logischer Name bezeichnet. Sein Wert gibt bestimmte PHP-Klassen und -Methoden nach einem bestimmten Muster an.

// src/Acme/BlogBundle/Controller/BlogController.php
namespace Acme\BlogBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class BlogController extends Controller
{
  public function showAction($slug)
  {
    $blog = // use the $slug variable to query the database
    return $this->render('AcmeBlogBundle:Blog:show.html.twig', array(
      'blog' => $blog,
    ));
  }
}

Wenn Sie nun /blog/my-post erneut besuchen, wird der showAction-Controller ausgeführt und der Wert der $slug-Variablen ist my- Beitrag

Router-Ziel für Symfogy2: Eine angeforderte URL dem Controller zuordnen.

Routing: Ein internes Geheimnis

Wenn eine Anfrage an eine Anwendung gesendet wird, enthält sie eine Adresse der Ressource, die der Client erhalten möchte. Diese Adresse wird URL oder URI genannt. Es kann sich um /contact,/blog/read-me oder andere Stile handeln.

GET /blog/my-blog-post

Das Ziel des Symfony2-Routingsystems besteht darin, diese URLs zu analysieren und zu entscheiden, welcher Controller ausgeführt werden soll, um auf die Anfrage zu antworten.

Der gesamte Routing-Prozess kann unterteilt werden in:

1. Die Anfrage wird vom Front-End-Controller (app.php) von Symfony2 verarbeitet.
2.Symfony2-Kern (Kernel) fordert den Router auf, die Anfrage zu prüfen.
3. Der Router ordnet die empfangene URL einem bestimmten Pfad zu und gibt relevante Informationen zurück, einschließlich des Controllers, der ausgeführt werden soll.
4. Der Symfony2-Kern führt den Controller aus, der schließlich ein Antwortobjekt zurückgibt.

Die Router-Schicht ist ein Tool, das die empfangene URL in einen bestimmten Controller umwandelt, der ausgeführt werden soll.

Routen erstellen

Symfony lädt alle Routen für Ihre Anwendung aus einer einzigen Routing-Konfigurationsdatei. Diese Datei heißt normalerweise app/config/routing.yml. Es kann so konfiguriert werden, dass es Dateien wie XML- oder PHP-Dateien enthält.

YAML-Format:

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

XML-Format:

<!-- app/config/config.xml -->
<framework:config ...>
  <!-- ... -->
  <framework:router resource="%kernel.root_dir%/config/routing.xml" />
</framework:config>

>

PHP-Codeformat:

// app/config/config.php
$container->loadFromExtension('framework', array(
  // ...
  'router'    => array('resource' => '%kernel.root_dir%/config/routing.php'),
));

Grundlegende Routing-Konfiguration

Es ist sehr einfach, eine Route zu definieren, normalerweise verfügt eine Anwendung über viele Routings. Eine Basisroute besteht aus zwei Teilen: dem Musterteil und dem Standard-Array-Teil.

Zum Beispiel:

YAML-Format:

_welcome:
  pattern:  /
  defaults: { _controller: AcmeDemoBundle:Main:homepage }

XML-Format:

<?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" pattern="/">
    <default key="_controller">AcmeDemoBundle:Main:homepage</default>
  </route>
</routes>

PHP-Codeformat:

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('_welcome', new Route('/', array(
  '_controller' => 'AcmeDemoBundle:Main:homepage',
)));
return $collection;

Diese Route entspricht der Homepage (/) und wird AcmeDemoBundle:Main zugeordnet: Homepage-Controller. Der _controller-String wird von Symfony2 in eine entsprechende PHP-Funktion übersetzt und ausgeführt.

Routenführung mit Platzhaltern

Natürlich unterstützt das Routingsystem noch weitere interessante Routen. Viele Routen enthalten einen oder mehrere benannte Platzhalter.

YAML-Format:

blog_show:
  pattern:  /blog/{slug}
  defaults: { _controller: AcmeBlogBundle:Blog:show }

XML-Format:

>

PHP-Codeformat:

<?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" pattern="/blog/{slug}">
    <default key="_controller">AcmeBlogBundle:Blog:show</default>
  </route>
</routes>

Dieses Muster stimmt mit jeder URL überein, die /blog/* ähnelt. Werte, die mit dem Platzhalter {slug} übereinstimmen, werden im Controller verwendet. Mit anderen Worten: Wenn die URL /blog/hello-world lautet, lautet der Wert der Variable $slug hello-world und dieser Wert ist im Controller verfügbar. Dieses Muster passt nicht zu etwas wie /blog, da standardmäßig alle Platzhalter erforderlich sind. Natürlich können Sie dies ändern, indem Sie diese Platzhalter im Standardarray zuweisen.

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog_show', new Route('/blog/{slug}', array(
  '_controller' => 'AcmeBlogBundle:Blog:show',
)));
return $collection;

Erforderliche und optionale Platzhalter

Fügen wir eine neue Route hinzu, die eine Liste aller verfügbaren Blogs anzeigt.

YAML-Format:

XML-Format:

blog:
  pattern:  /blog
  defaults: { _controller: AcmeBlogBundle:Blog:index }

>

PHP-Codeformat:

<?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" pattern="/blog">
    <default key="_controller">AcmeBlogBundle:Blog:index</default>
  </route>
</routes>

Bisher waren unsere Routen sehr einfache Routingmuster. Die darin enthaltenen Nicht-Platzhalter werden exakt abgeglichen.

Wenn Sie möchten, dass diese Route Paging unterstützt, z. B. dass /blog/2 die zweite Seite des Blogs anzeigt, müssen Sie der vorherigen Route einen neuen Platzhalter {page} hinzufügen.

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog', new Route('/blog', array(
  '_controller' => 'AcmeBlogBundle:Blog:index',
)));
return $collection;

YAML-Format:

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" pattern="/blog/{page}">
    <default key="_controller">AcmeBlogBundle:Blog:index</default>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog', new Route('/blog/{page}', array(
  '_controller' => 'AcmeBlogBundle:Blog:index',
)));
return $collection;

   

跟之前的{slug}占位符一样{page}占位符将会在你的controller内部可用，它的值可以用于表示要显示的blog值的页码。但是要清楚，因为占位符默认情况下都是必需的，该路由也将不再匹配之前的/blog URL，这时候你如果还像看第一页的话，就必须通过/blog/1 URL来访问了。要解决该问题，可以在该路由的defaults数组中指定{page}的默认值。

YAML格式：

blog:
  pattern:  /blog/{page}
  defaults: { _controller: AcmeBlogBundle:Blog:index, page: 1 }

   

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" pattern="/blog/{page}">
    <default key="_controller">AcmeBlogBundle:Blog:index</default>
    <default key="page">1</default>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog', new Route('/blog/{page}', array(
  '_controller' => 'AcmeBlogBundle:Blog:index',
  'page' => 1,
)));
return $collection;

   

通过添加page到defaults键， {page}占位符就不再是必需的。这时候 /blog将会被匹配并且page参数被设置为1，URL /blog/2 也会被匹配。

添加要求约束

看看下面这些路由：

YAML格式：

blog:
  pattern:  /blog/{page}
  defaults: { _controller: AcmeBlogBundle:Blog:index, page: 1 }
blog_show:
  pattern:  /blog/{slug}
  defaults: { _controller: AcmeBlogBundle:Blog:show }

   

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" pattern="/blog/{page}">
    <default key="_controller">AcmeBlogBundle:Blog:index</default>
    <default key="page">1</default>
  </route>
  <route id="blog_show" pattern="/blog/{slug}">
    <default key="_controller">AcmeBlogBundle:Blog:show</default>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog', new Route('/blog/{page}', array(
  '_controller' => 'AcmeBlogBundle:Blog:index',
  'page' => 1,
)));
$collection->add('blog_show', new Route('/blog/{show}', array(
  '_controller' => 'AcmeBlogBundle:Blog:show',
)));
return $collection;

   

你发现问题了吗？注意这两个路由都能匹配像/blog/* 类型的URL。Symfony只会选择第一个与之匹配的路由。

换句话说，blog_show将永远不会被像/blog/* 类型的URL匹配。而像 /blog/my-blog-post这样的URL也会被blog路由匹配，并且page变量会获得my-blog-post这样的值。

这肯定不可以，那么怎么办呢？答案是给路由添加约束要求requirements。

在blog路由中占位符{page}理想状态下只匹配整数值。幸运的是正则表达可以很容易的满足这一要求。

YAML格式：

blog:
  pattern:  /blog/{page}
  defaults: { _controller: AcmeBlogBundle:Blog:index, page: 1 }
  requirements:
    page: \d+

   

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" pattern="/blog/{page}">
    <default key="_controller">AcmeBlogBundle:Blog:index</default>
    <default key="page">1</default>
    <requirement key="page">\d+</requirement>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('blog', new Route('/blog/{page}', array(
  '_controller' => 'AcmeBlogBundle:Blog:index',
  'page' => 1,
), array(
  'page' => '\d+',
)));
return $collection;

   

这里 \d+ 约束是一个正则表达式，它指定了{page}只接受整数。这样像/blog/my-blog-post就不再被匹配了。这时候，它才会被blog_show路由匹配。因为参数的约束都是正则表达式，所以其复杂程度和灵活性都有你来决定了。
假设home页使用两种语言则可以这样配置路由：

YAML格式：

homepage:
  pattern:  /{culture}
  defaults: { _controller: AcmeDemoBundle:Main:homepage, culture: en }
  requirements:
    culture: en|fr

   

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="homepage" pattern="/{culture}">
    <default key="_controller">AcmeDemoBundle:Main:homepage</default>
    <default key="culture">en</default>
    <requirement key="culture">en|fr</requirement>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('homepage', new Route('/{culture}', array(
  '_controller' => 'AcmeDemoBundle:Main:homepage',
  'culture' => 'en',
), array(
  'culture' => 'en|fr',
)));
return $collection;

   

添加HTTP 方法约束

除了URL，你还可以匹配请求的方法（GET,HEAD,POST,PUT,DELETE等）。假设你有一个联系表单有两个controller，一个用于显示表单（使用GET请求）一个用于处理提交的表单（POST请求）。它的配置如下：

YAML格式：

contact:
  pattern: /contact
  defaults: { _controller: AcmeDemoBundle:Main:contact }
  requirements:
    _method: GET
contact_process:
  pattern: /contact
  defaults: { _controller: AcmeDemoBundle:Main:contactProcess }
  requirements:
    _method: POST

   

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="contact" pattern="/contact">
    <default key="_controller">AcmeDemoBundle:Main:contact</default>
    <requirement key="_method">GET</requirement>
  </route>
  <route id="contact_process" pattern="/contact">
    <default key="_controller">AcmeDemoBundle:Main:contactProcess</default>
    <requirement key="_method">POST</requirement>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('contact', new Route('/contact', array(
  '_controller' => 'AcmeDemoBundle:Main:contact',
), array(
  '_method' => 'GET',
)));
$collection->add('contact_process', new Route('/contact', array(
  '_controller' => 'AcmeDemoBundle:Main:contactProcess',
), array(
  '_method' => 'POST',
)));
return $collection;

   

尽管这两个路由拥有同一个URL模式定义（/contact)，但是第一个路由只会匹配GET请求，而第二个只会匹配POST请求。这就意味着你可以通过同一个URL来显示表单并提交表单，而用不同的controller对他们进行处理。如果没有指定_method约束，那么该路由会匹配所有请求方法。跟其它约束一样，_method约束也接受正则表达式，如果只想匹配GET或者POST那么你可以用GET|POST

高级路由例子：

Symfony2中具备一切让你创建任何形式路由的条件。

YAML格式：

article_show:
 pattern: /articles/{culture}/{year}/{title}.{_format}
 defaults: { _controller: AcmeDemoBundle:Article:show, _format: html }
 requirements:
   culture: en|fr
   _format: html|rss
   year:   \d+

   

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" pattern="/articles/{culture}/{year}/{title}.{_format}">
    <default key="_controller">AcmeDemoBundle:Article:show</default>
    <default key="_format">html</default>
    <requirement key="culture">en|fr</requirement>
    <requirement key="_format">html|rss</requirement>
    <requirement key="year">\d+</requirement>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('homepage', new Route('/articles/{culture}/{year}/{title}.{_format}', array(
  '_controller' => 'AcmeDemoBundle:Article:show',
  '_format' => 'html',
), array(
  'culture' => 'en|fr',
  '_format' => 'html|rss',
  'year' => '\d+',
)));
return $collection;

   

上面的路由，在匹配时只会匹配{culture}部分值为en或者fr并且{year}的值为数字的URL。该路由还告诉我们，可以用在占位符之间使用区间代替斜线。

它能够匹配如下URL：

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

这其中有个特殊的路由参数 _format，在使用该参数时，其值变为请求格式。这种请求格式相当于Respose对象的Content-Type，比如json请求格式会翻译成一个Content-Type为application/json.该参数可以用于在controller中为每个_format渲染一个不同的模板。它是一个很强的方式来渲染同一个内容到不同的格式。

特殊的路由参数：

正如你所看到的，每一个路由参数或者默认值最终都是作为一个controller方法输入参数被使用。另外，有三个参数比较特别，它们每一个都在你的应用程序中增加一个唯一功能。

_controller: 这个参数决定了当路由匹配时，哪个controller被执行。
_format: 用于设置请求格式。
_locale: 用于在session上设置本地化。

Controller的命名模式：

每一个路由必须有一个_controller参数，它决定了当路由匹配时哪个controller应该被执行。该参数使用单一的字符串模式，被称为logical controller name。

通过它Symfony可以映射到一个特定的PHP方法和类。该模式有三部分，每一部分用冒号分割开：

bundle:controller:action

   

比如_controller 的值为 AcmeBlogBundle:Blog:show 意思是AcmeBlogBundle bundle中BlogController类里面的showAction方法。

// src/Acme/BlogBundle/Controller/BlogController.php
namespace Acme\BlogBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class BlogController extends Controller
{
  public function showAction($slug)
  {
    // ...
  }
}

   

Symfony会自动把它们的添加相应的后缀，Blog=>BlogController, show => showAction。

你也可以使用它的完全限定名和方法来给_controller赋值，Acme\BlogBundle\Controller\BlogController::showAction 但一般为了简洁灵活而是用逻辑名称。另外除了上面两种形式外，Symfony还支持第三种方式只有一个冒号分割符，如service_name:indexAction来为_controller赋一个作为服务使用的controller。

路由参数和控制器参数

路由参数非常重要，因为每一个路由参数都会转变成一个控制器参数被在方法中使用。

public function showAction($slug)
{
 // ...
}

   

事实上，全部的defaults集合和表单的参数值合并到一个单独的数组中。这个数组中的每个键都会成为controller方法的参数。换句话说，你的controller方法的每一个参数，Symfony都会从路由参数中查找并把找到的值赋给给参数。上面例子中的变量 $culture, $year,$title,$_format,$_controller 都会作为showAction()方法的参数。因为占位符和defaults集合被合并到一起，即使$_controller变量也是一样。你也可以使用一个特殊的变量$_route 来指定路由的名称。

包括外部路由资源

所有的路由资源的都是通过一个单一的配置文件导入的。通常是app/config/routing.yml。当然你可能想从别处导入路由资源，比如你定义的bundle中的路由资源，你可以这样导入：

YAML格式：

# app/config/routing.yml
acme_hello:
  resource: "@AcmeHelloBundle/Resources/config/routing.yml"

   

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">
  <import resource="@AcmeHelloBundle/Resources/config/routing.xml" />
</routes>

   

PHP代码格式：

// app/config/routing.php
use Symfony\Component\Routing\RouteCollection;
$collection = new RouteCollection();
$collection->addCollection($loader->import("@AcmeHelloBundle/Resources/config/routing.php"));
return $collection;

   

在使用YAML导入资源时，键（比如acme_hello)是没有意义的，只是用来保证该资源唯一不被其它行覆盖。使用resources key加载给定的路由资源。在这个示例中资源是一个全路径文件，@AcmeHelloBundle是简写语法，它会被指向bundle路径。被导入的文件内容如下：

YAML格式：

# src/Acme/HelloBundle/Resources/config/routing.yml
acme_hello:
   pattern: /hello/{name}
   defaults: { _controller: AcmeHelloBundle:Hello:index }

   

XML格式：

<!-- src/Acme/HelloBundle/Resources/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="acme_hello" pattern="/hello/{name}">
    <default key="_controller">AcmeHelloBundle:Hello:index</default>
  </route>
</routes>

   

PHP代码格式：

// src/Acme/HelloBundle/Resources/config/routing.php
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('acme_hello', new Route('/hello/{name}', array(
  '_controller' => 'AcmeHelloBundle:Hello:index',
)));
return $collection;

   

这个文件中的路由会被解析并跟主要的路由文件内容一起被加载。

给导入的路由资源添加前缀

你可以为导入的路由资源选择一个前缀，比如说假设你想acme_hello路由有一个这样的 匹配模式：/admin/hello/{name} 而不是直接的 /hello/{name}

那么你在导入它的时候可以为其指定prefix。

YAML格式：

# app/config/routing.yml
acme_hello:
  resource: "@AcmeHelloBundle/Resources/config/routing.yml"
  prefix:  /admin

   

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">
  <import resource="@AcmeHelloBundle/Resources/config/routing.xml" prefix="/admin" />
</routes>

   

PHP代码格式：

// app/config/routing.php
use Symfony\Component\Routing\RouteCollection;
$collection = new RouteCollection();
$collection->addCollection($loader->import("@AcmeHelloBundle/Resources/config/routing.php"), '/admin');
return $collection;

   

当该外部路由资源加载的时候字符串 /admin 将被插入到匹配模式的前面。

可视化并调试路由

当你添加和个性化路由时，能够看到它并能获取一些细节信息将是非常有用的。一个好的查看你应用程序的路由的方法是通过router:debug 命令行工具。

在你项目目录下执行如下命令：

$ php app/console router:debug

   

将会输出你应用程序的所有路由。你也可以在该命令后面添加某个路由的名字来获取单个路由信息

$ php app/console router:debug article_show

   

生成URL

一个路由系统应该也能用来生成URL。事实上，路由系统是一个双向的系统，映射URL到controller+parameters 和 回对应到 一个URL。可以使用match()和generate（）方法来操作。比如：

$params = $router->match('/blog/my-blog-post');
// array('slug' => 'my-blog-post', '_controller' => 'AcmeBlogBundle:Blog:show')
$uri = $router->generate('blog_show', array('slug' => 'my-blog-post'));
// /blog/my-blog-post

   

要生成一个URL，你需要指定路由的名称（比如 blog_show)和任意的通配符（比如：slug=my-blog-post)作为参数。通过这些信息，可以生成任意的URL。

class MainController extends Controller
{
  public function showAction($slug)
  {
   // ...
   $url = $this->get('router')->generate('blog_show', array('slug' => 'my-blog-post'));
  }
}

   

那么如何从模板内部来生成URL呢？如果你的应用程序前端使用了AJAX请求，你也许想能够基于你的路由配置在javascript中生成URL，通过使用

FOSJsRoutingBundle(https://github.com/FriendsOfSymfony/FOSJsRoutingBundle) 你可以做到：

var url = Routing.generate('blog_show', { "slug": 'my-blog-post'});

   

生成绝对路径的URL

默认的情况下，路由器生成相对路径的URL（比如 /blog).要生成一个绝对路径的URL，只需要传入一个true到generate方法作为第三个参数值即可。

$router->generate('blog_show', array('slug' => 'my-blog-post'), true);
// http://www.example.com/blog/my-blog-post

   

当生成一个绝对路径URL时主机是当前请求对象的主机，这个是基于PHP提供的服务器信息自动决定的。当你需要为运行子命令行的脚本生成一个绝对URL时，你需要在Request对象上手动设置期望的主机头。

   
$request->headers->set('HOST', 'www.example.com');

   

生成带有查询字符串的URL

generate()带有一个数组通配符值来生成URI。 但是如果你传入额外的值，它将被添加到URI作为查询字符串：

$router->generate('blog', array('page' => 2, 'category' => 'Symfony'));
// /blog/2?category=Symfony

   

从模板中生成URL

最常用到生成URL的地方是从模板中链接两个页面时，这来需要使用一个模板帮助函数：

Twig格式：

<a href="{{ path(&#39;blog_show&#39;, { &#39;slug&#39;: &#39;my-blog-post&#39; }) }}">
 Read this blog post.
</a>

   

PHP格式：

<a href="<?php echo $view[&#39;router&#39;]->generate(&#39;blog_show&#39;, array(&#39;slug&#39; => &#39;my-blog-post&#39;)) ?>">
  Read this blog post.
</a>

   

也可以生成绝对路径：

Twig格式：

<a href="{{ url(&#39;blog_show&#39;, { &#39;slug&#39;: &#39;my-blog-post&#39; }) }}">
 Read this blog post.
</a>

   

PHP格式：

<a href="<?php echo $view[&#39;router&#39;]->generate(&#39;blog_show&#39;, array(&#39;slug&#39; => &#39;my-blog-post&#39;), true) ?>">
  Read this blog post.
</a>

   

强制路由使用HTTPS或者HTTP

有时候为了安全起见，你需要你的站点必须使用HTTPS协议访问。这时候路由组件可以通过_scheme 约束来强迫URI方案。比如：

YAML格式：

secure:
  pattern: /secure
  defaults: { _controller: AcmeDemoBundle:Main:secure }
  requirements:
    _scheme: https

   

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="secure" pattern="/secure">
    <default key="_controller">AcmeDemoBundle:Main:secure</default>
    <requirement key="_scheme">https</requirement>
  </route>
</routes>

   

PHP代码格式：

use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
$collection = new RouteCollection();
$collection->add('secure', new Route('/secure', array(
  '_controller' => 'AcmeDemoBundle:Main:secure',
), array(
  '_scheme' => 'https',
)));
return $collection;

   

上面的路由定义就是强迫secure路由使用HTTPS协议访问。

反之，当生成secure 的URL的时候，路由系统会根据当前的访问协议方案生成相应的访问协议。比如当前是HTTP，则会自动生成HTTPS访问；如果是HTTPS访问，那么就也会相应的生成HTTPS访问。

# 如果方案是 HTTPS
{{ path('secure') }}
# 生成 /secure
# 如果方案是 HTTP
{{ path('secure') }}
# 生成 https://example.com/secure

当然你也可以通过设置_scheme为HTTP，来强制使用HTTP访问协议。除了上面说的强迫使用HTTPS协议访问的设置方法外，还有一种用于站点区域设置

使用requires_channel 比如你想让你站点中/admin 下面的所有路由都必须使用HTTPS协议访问，或者你的安全路由定义在第三方bundle时使用。

总结：

路由系统是一个为将接收的请求URL映射到被调用来处理该请求的controller函数的系统。它既能够让你生成漂亮的URL同时又能保持你的应用程序功能跟这些URL解耦。路由系统是双向机制的，也就是说它们也可以用来生成URL。

希望本文所述对大家基于Symfony框架的PHP程序设计有所帮助。

更多Symfony2学习笔记之系统路由详解相关文章请关注PHP中文网！