路由（Routing）¶

Router 组件允许定义用户请求对应到哪个控制器或动作。Router 解析 URI 以确定这些信息。路由器有两种模式：MVC 模式和匹配模式(match-only)。第一种模式是使用MVC应用程序的理想选择。

定义路由（Defining Routes）¶

在 MVC 模式中 Phalcon\Mvc\Router 提供了一套简单方便的高级路由功能。你可以自定义路由规则，对应到你需要的 controllers/actions 上。路由的定义如下：

<?php

use Phalcon\Mvc\Router;

// Create the router
$router = new Router();

// Define a route
$router->add(
    "/admin/users/my-profile",
    array(
        "controller" => "users",
        "action"     => "profile"
    )
);

// Another route
$router->add(
    "/admin/users/change-password",
    array(
        "controller" => "users",
        "action"     => "changePassword"
    )
);

$router->handle();

add() 方法接受一个匹配模式作为第一个参数，一组可选的路径作为第二个参数。如上，如果URI就是/admin/users/my-profile的话，那么 “users” 控制的 “profile” 方法将被调用。当然路由器并不马上就调用这个方法，它只是收集这些信息并且通知相应的组件（比如 Phalcon\Mvc\Dispatcher ）应该调用这个控制器的这个动作。

一个应用程序可以由很多路径，一个一个定义是一个非常笨重的工作。这种情况下我们可以创建一个更加灵活的路由：

<?php

use Phalcon\Mvc\Router;

// Create the router
$router = new Router();

// Define a route
$router->add(
    "/admin/:controller/a/:action/:params",
    array(
        "controller" => 1,
        "action"     => 2,
        "params"     => 3
    )
);

在上面的例子中我们通过使用通配符定义了一个可以匹配多个URI的路由，比如，访问这个URL（/admin/users/a/delete/dave/301），那么：

Controller	users
Action	delete
Parameter	dave
Parameter	301

方法 add() 第一个参数，可以使用预定义的占位符和正则表达式的修饰符来作为匹配模式。所有的路由匹配模式第一个字符必须是斜杠（/）。正则表达式的使用跟 PCRE regular expressions 相同。注意，不需要添加正则表达式分隔符，所有路由匹配模式是不区分大小写的。

第二个参数，定义如何将匹配到的数据绑定到对应的 controller/action/parameters。Matching parts are placeholders or subpatterns delimited by parentheses (round brackets). In the example given above, the first subpattern matched (:controller) is the controller part of the route, the second the action and so on.

默认占位符对应正则表达式（Default Placeholders Regular Expressions）¶

这些占位符帮助编写开发人员更简单的书写正则表达式，而且容易理解，以下默认支持的占位符：

Placeholder	Regular Expression	Usage
`/:module`	`/([\\w0-9\\_\\-]+)`	Matches a valid module name with alpha-numeric characters only
`/:controller`	`/([\\w0-9\\_\\-]+)`	Matches a valid controller name with alpha-numeric characters only
`/:action`	`/([\\w0-9\\_\\-]+)`	Matches a valid action name with alpha-numeric characters only
`/:params`	`(/.)`	Matches a list of optional words separated by slashes. Only use this placeholder at the end of a route
`/:namespace`	`/([\\w0-9\\_\\-]+)`	Matches a single level namespace name
`/:int`	`/([0-9]+)`	Matches an integer parameter

Controller names are camelized, this means that characters (-) and (_) are removed and the next character is uppercased. For instance, some_controller is converted to SomeController.

Since you can add many routes as you need using the add() method, the order in which routes are added indicate their relevance, latest routes added have more relevance than first added. Internally, all defined routes are traversed in reverse order until Phalcon\Mvc\Router finds the one that matches the given URI and processes it, while ignoring the rest.

设置占位符对应正则表达式（Setting Placeholders Regular Expressions）¶

<?php

    $router = new Phalcon\Mvc\Router(false);

    // Default
    $router->add('/:controller/:action/:params', array(
        "controller" => 1,
        "action" => 2,
        "params" => 3,
    ));
    // Setting new regular
    $router->add('/:controller/:action/:params', array(
        "controller" => 1,
        "action" => 2,
        "params" => 4,
    ), array(
        '/:controller' => '/([a-zA-Z0-9_-]+)',
        '/:action' => '/([a-zA-Z0-9_-]+)',
        '/:params' => '([/]?)([a-zA-Z0-9_-]+)?',
    ));

参数名称（Parameters with Names）¶

The example below demonstrates how to define names to route parameters:

<?php

$router->add(
    "/news/([0-9]{4})/([0-9]{2})/([0-9]{2})/:params",
    array(
        "controller" => "posts",
        "action"     => "show",
        "year"       => 1, // ([0-9]{4})
        "month"      => 2, // ([0-9]{2})
        "day"        => 3, // ([0-9]{2})
        "params"     => 4  // :params
    )
);

In the above example, the route doesn’t define a “controller” or “action” part. These parts are replaced with fixed values (“posts” and “show”). The user will not know the controller that is really dispatched by the request. Inside the controller, those named parameters can be accessed as follows:

<?php

use Phalcon\Mvc\Controller;

class PostsController extends Controller
{
    public function indexAction()
    {

    }

    public function showAction()
    {
        // Get "year" parameter
        $year = $this->dispatcher->getParam("year");
        // Or
        $year = $this->request->getParam("year");

        // Get "month" parameter
        $month = $this->dispatcher->getParam("month");
        // Or
        $month = $this->request->getParam("month");

        // Get "day" parameter
        $day = $this->dispatcher->getParam("day");
        // Or
        $day = $this->request->getParam("day");

        // ...
    }
}

Note that the values of the parameters are obtained from the dispatcher. This happens because it is the component that finally interacts with the drivers of your application. Moreover, there is also another way to create named parameters as part of the pattern:

<?php

$router->add(
    "/documentation/{chapter}/{name}.{type:[a-z]+}",
    array(
        "controller" => "documentation",
        "action"     => "show"
    )
);

You can access their values in the same way as before:

<?php

use Phalcon\Mvc\Controller;

class DocumentationController extends Controller
{
    public function showAction()
    {
        // Get "name" parameter
        $name = $this->dispatcher->getParam("name");

        // Get "type" parameter
        $type = $this->dispatcher->getParam("type");

        // ...
    }
}

短语法（Short Syntax）¶

If you don’t like using an array to define the route paths, an alternative syntax is also available. The following examples produce the same result:

<?php

// Short form
$router->add("/posts/{year:[0-9]+}/{title:[a-z\-]+}", "Posts::show");

// Array form
$router->add(
    "/posts/([0-9]+)/([a-z\-]+)",
    array(
       "controller" => "posts",
       "action"     => "show",
       "year"       => 1,
       "title"      => 2
    )
);

$router = new Phalcon\Mvc\Router;
$router->add('/{namespace:[a-z\-]+}/{controller:[a-z\-]+}{action:[/a-z\-]*}', NULL)
    ->convert('namespace', function ($namespace) {
        return ucfirst($namespace);
    })->convert('controller', function ($controller) {
        return ucfirst($controller);
    });

混合使用数组和短语法（Mixing Array and Short Syntax）¶

Array and short syntax can be mixed to define a route, in this case note that named parameters automatically are added to the route paths according to the position on which they were defined:

<?php

// First position must be skipped because it is used for
// the named parameter 'country'
$router->add('/news/{country:[a-z]{2}}/([a-z+])/([a-z\-+])',
    array(
        'section' => 2, // Positions start with 2
        'article' => 3
    )
);

路由到模块（Routing to Modules）¶

You can define routes whose paths include modules. This is specially suitable to multi-module applications. It’s possible define a default route that includes a module wildcard:

<?php

use Phalcon\Mvc\Router;

$router = new Router(false);

$router->add(
    '/:module/:controller/:action/:params',
    array(
        'module'     => 1,
        'controller' => 2,
        'action'     => 3,
        'params'     => 4
    )
);

In this case, the route always must have the module name as part of the URL. For example, the following URL: /admin/users/edit/sonny, will be processed as:

Module	admin
Controller	users
Action	edit
Parameter	sonny

Or you can bind specific routes to specific modules:

<?php

$router->add(
    "/login",
    array(
        'module'     => 'backend',
        'controller' => 'login',
        'action'     => 'index'
    )
);

$router->add(
    "/products/:action",
    array(
        'module'     => 'frontend',
        'controller' => 'products',
        'action'     => 1
    )
);

Or bind them to specific namespaces:

<?php

$router->add(
    "/:namespace/login",
    array(
        'namespace'  => 1,
        'controller' => 'login',
        'action'     => 'index'
    )
);

Namespaces/class names must be passed separated:

<?php

$router->add(
    "/login",
    array(
        'namespace'  => 'Backend\Controllers',
        'controller' => 'login',
        'action'     => 'index'
    )
);

限制 HTTP 请求传入方式（HTTP Method Restrictions）¶

When you add a route using simply add(), the route will be enabled for any HTTP method. Sometimes we can restrict a route to a specific method, this is especially useful when creating RESTful applications:

<?php

// This route only will be matched if the HTTP method is GET
$router->addGet("/products/edit/{id}", "Products::edit");

// This route only will be matched if the HTTP method is POST
$router->addPost("/products/save", "Products::save");

// This route will be matched if the HTTP method is POST or PUT
$router->add("/products/update", "Products::update")->via(array("POST", "PUT"));

使用转换（Using conversors）¶

Conversors allow you to freely transform the route’s parameters before passing them to the dispatcher. The following examples show how to use them:

<?php

// The action name allows dashes, an action can be: /products/new-ipod-nano-4-generation
$router
    ->add('/products/{slug:[a-z\-]+}', array(
        'controller' => 'products',
        'action'     => 'show'
    ))
    ->convert('slug', function ($slug) {
        // Transform the slug removing the dashes
        return str_replace('-', '', $slug);
    });

路由分组（Groups of Routes）¶

If a set of routes have common paths they can be grouped to easily maintain them:

<?php

use Phalcon\Mvc\Router;
use Phalcon\Mvc\Router\Group as RouterGroup;

$router = new Router();

// Create a group with a common module and controller
$blog = new RouterGroup(
    array(
        'module'     => 'blog',
        'controller' => 'index'
    )
);

// All the routes start with /blog
$blog->setPrefix('/blog');

// Add a route to the group
$blog->add(
    '/save',
    array(
        'action' => 'save'
    )
);

// Add another route to the group
$blog->add(
    '/edit/{id}',
    array(
        'action' => 'edit'
    )
);

// This route maps to a controller different than the default
$blog->add(
    '/blog',
    array(
        'controller' => 'blog',
        'action'     => 'index'
    )
);

// Add the group to the router
$router->mount($blog);

You can move groups of routes to separate files in order to improve the organization and code reusing in the application:

<?php

use Phalcon\Mvc\Router\Group as RouterGroup;

class BlogRoutes extends RouterGroup
{
    public function initialize()
    {
        // Default paths
        $this->setPaths(
            array(
                'module'    => 'blog',
                'namespace' => 'Blog\Controllers'
            )
        );

        // All the routes start with /blog
        $this->setPrefix('/blog');

        // Add a route to the group
        $this->add(
            '/save',
            array(
                'action' => 'save'
            )
        );

        // Add another route to the group
        $this->add(
            '/edit/{id}',
            array(
                'action' => 'edit'
            )
        );

        // This route maps to a controller different than the default
        $this->add(
            '/blog',
            array(
                'controller' => 'blog',
                'action'     => 'index'
            )
        );
    }
}

Then mount the group in the router:

<?php

// Add the group to the router
$router->mount(new BlogRoutes());

匹配路由（Matching Routes）¶

A valid URI must be passed to the Router so that it can process it and find a matching route. By default, the routing URI is taken from the $_GET['_url'] variable that is created by the rewrite engine module. A couple of rewrite rules that work very well with Phalcon are:

RewriteEngine On
RewriteCond   %{REQUEST_FILENAME} !-d
RewriteCond   %{REQUEST_FILENAME} !-f
RewriteRule   ^((?s).*)$ index.php?_url=/$1 [QSA,L]

In this configuration, any requests to files or folders that don’t exist will be sent to index.php.

The following example shows how to use this component in stand-alone mode:

<?php

use Phalcon\Mvc\Router;

// Creating a router
$router = new Router();

// Define routes here if any
// ...

// Taking URI from $_GET["_url"]
$router->handle();

// Or Setting the URI value directly
$router->handle("/employees/edit/17");

// Getting the processed controller
echo $router->getControllerName();

// Getting the processed action
echo $router->getActionName();

// Get the matched route
$route = $router->getMatchedRoute();

路由命名（Naming Routes）¶

Each route that is added to the router is stored internally as a Phalcon\Mvc\Router\Route object. That class encapsulates all the details of each route. For instance, we can give a name to a path to identify it uniquely in our application. This is especially useful if you want to create URLs from it.

<?php

$route = $router->add("/posts/{year}/{title}", "Posts::show");

$route->setName("show-posts");

// Or just

$router->add("/posts/{year}/{title}", "Posts::show")->setName("show-posts");

Then, using for example the component Phalcon\Mvc\Url we can build routes from its name:

<?php

// Returns /posts/2012/phalcon-1-0-released
echo $url->get(
    array(
        "for"   => "show-posts",
        "year"  => "2012",
        "title" => "phalcon-1-0-released"
    )
);

范例（Usage Examples）¶

The following are examples of custom routes:

<?php

// Matches "/system/admin/a/edit/7001"
$router->add(
    "/system/:controller/a/:action/:params",
    array(
        "controller" => 1,
        "action"     => 2,
        "params"     => 3
    )
);

// Matches "/es/news"
$router->add(
    "/([a-z]{2})/:controller",
    array(
        "controller" => 2,
        "action"     => "index",
        "language"   => 1
    )
);

// Matches "/es/news"
$router->add(
    "/{language:[a-z]{2}}/:controller",
    array(
        "controller" => 2,
        "action"     => "index"
    )
);

// Matches "/admin/posts/edit/100"
$router->add(
    "/admin/:controller/:action/:int",
    array(
        "controller" => 1,
        "action"     => 2,
        "id"         => 3
    )
);

// Matches "/posts/2015/02/some-cool-content"
$router->add(
    "/posts/([0-9]{4})/([0-9]{2})/([a-z\-]+)",
    array(
        "controller" => "posts",
        "action"     => "show",
        "year"       => 1,
        "month"      => 2,
        "title"      => 4
    )
);

// Matches "/manual/en/translate.adapter.html"
$router->add(
    "/manual/([a-z]{2})/([a-z\.]+)\.html",
    array(
        "controller" => "manual",
        "action"     => "show",
        "language"   => 1,
        "file"       => 2
    )
);

// Matches /feed/fr/le-robots-hot-news.atom
$router->add(
    "/feed/{lang:[a-z]+}/{blog:[a-z\-]+}\.{type:[a-z\-]+}",
    "Feed::get"
);

// Matches /api/v1/users/peter.json
$router->add(
    '/api/(v1|v2)/{method:[a-z]+}/{param:[a-z]+}\.(json|xml)',
    array(
        'controller' => 'api',
        'version'    => 1,
        'format'     => 4
    )
);

Beware of characters allowed in regular expression for controllers and namespaces. As these become class names and in turn they’re passed through the file system could be used by attackers to read unauthorized files. A safe regular expression is: /([a-zA-Z0-9\_\-]+)

默认行为（Default Behavior）¶

Phalcon\Mvc\Router has a default behavior that provides a very simple routing that always expects a URI that matches the following pattern: /:controller/:action/:params

For example, for a URL like this http://phalconphp.com/documentation/show/about.html, this router will translate it as follows:

Controller	documentation
Action	show
Parameter	about.html

If you don’t want the router to have this behavior, you must create the router passing false as the first parameter:

<?php

use Phalcon\Mvc\Router;

// Create the router without default routes
$router = new Router(false);

设置默认路由（Setting the default route）¶

When your application is accessed without any route, the ‘/’ route is used to determine what paths must be used to show the initial page in your website/application:

<?php

$router->add(
    "/",
    array(
        'controller' => 'index',
        'action'     => 'index'
    )
);

没有找到路径（Not Found Paths）¶

If none of the routes specified in the router are matched, you can define a group of paths to be used in this scenario:

<?php

// Set 404 paths
$router->notFound(
    array(
        "controller" => "index",
        "action"     => "route404"
    )
);

This is typically for an Error 404 page.

设置默认路径（Setting default paths）¶

It’s possible to define default values for the module, controller or action. When a route is missing any of those paths they can be automatically filled by the router:

可以为通用路径中的 module, controller, action 定义默认值。当一个路由缺少其中任何一项时，路由器可以自动用默认值填充：

<?php

// Setting a specific default
$router->setDefaultModule('backend');
$router->setDefaultNamespace('Backend\Controllers');
$router->setDefaultController('index');
$router->setDefaultAction('index');

// Using an array
$router->setDefaults(
    array(
        'controller' => 'index',
        'action'     => 'index'
    )
);

处理结尾额外的斜杆（Dealing with extra/trailing slashes）¶

Sometimes a route could be accessed with extra/trailing slashes. Those extra slashes would lead to produce a not-found status in the dispatcher. You can set up the router to automatically remove the slashes from the end of handled route:

<?php

use Phalcon\Mvc\Router;

$router = new Router();

// Remove trailing slashes automatically
$router->removeExtraSlashes(true);

$router->add('/phalcon', array(
    'controller' => 'index',
    'action' =>  'index'
));

Or, you can modify specific routes to optionally accept trailing slashes:

<?php

// The [/]{0,1} allows this route to have optionally have a trailing slash
$router->add(
    '/{language:[a-z]{2}}/:controller[/]{0,1}',
    array(
        'controller' => 2,
        'action'     => 'index'
    )
);

设置处理结尾额外的斜杆，可以简化路由设置，设置前:

<?php

use Phalcon\Mvc\Router;

$router = new Router();
$router->add('/phalcon', array(
    'controller' => 'index',
    'action' =>  'index'
));

$router->add('/phalcon/', array(
    'controller' => 'index',
    'action' =>  'index'
));
// Or
$router->add('/phalcon[/]?', array(
    'controller' => 'index',
    'action' =>  'index'
));

设置后:

<?php

use Phalcon\Mvc\Router;

$router = new Router();
$router->removeExtraSlashes(true);
$router->add('/phalcon', array(
    'controller' => 'index',
    'action' =>  'index'
));

匹配回调函数（Match Callbacks）¶

Sometimes, routes should only be matched if they meet specific conditions. You can add arbitrary conditions to routes using the beforeMatch() callback. If this function return false, the route will be treated as non-matched:

<?php

$router->add('/login', array(
    'module'     => 'admin',
    'controller' => 'session'
))->beforeMatch(function ($uri, $route) {
    // Check if the request was made with Ajax
    if (isset($_SERVER['HTTP_X_REQUESTED_WITH'])
        && $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest') {
        return false;
    }
    return true;
});

You can re-use these extra conditions in classes:

<?php

class AjaxFilter
{
    public function check()
    {
        return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
    }
}

And use this class instead of the anonymous function:

<?php

$router->add('/get/info/{id}', array(
    'controller' => 'products',
    'action'     => 'info'
))->beforeMatch(array(new AjaxFilter(), 'check'));

限制主机名（Hostname Constraints）¶

The router allows you to set hostname constraints, this means that specific routes or a group of routes can be restricted to only match if the route also meets the hostname constraint:

<?php

$router->add('/login', array(
    'module'     => 'admin',
    'controller' => 'session',
    'action'     => 'login'
))->setHostName('admin.company.com');

The hostname can also be passed as a regular expressions:

<?php

$router->add('/login', array(
    'module'     => 'admin',
    'controller' => 'session',
    'action'     => 'login'
))->setHostName('([a-z]+).company.com');

In groups of routes you can set up a hostname constraint that apply for every route in the group:

<?php

use Phalcon\Mvc\Router\Group as RouterGroup;

// Create a group with a common module and controller
$blog = new RouterGroup(
    array(
        'module'     => 'blog',
        'controller' => 'posts'
    )
);

// Hostname restriction
$blog->setHostName('blog.mycompany.com');

// All the routes start with /blog
$blog->setPrefix('/blog');

// Default route
$blog->add(
    '/',
    array(
        'action' => 'index'
    )
);

// Add a route to the group
$blog->add(
    '/save',
    array(
        'action' => 'save'
    )
);

// Add another route to the group
$blog->add(
    '/edit/{id}',
    array(
        'action' => 'edit'
    )
);

// Add the group to the router
$router->mount($blog);

URI 来源（URI Sources）¶

By default the URI information is obtained from the $_GET['_url'] variable, this is passed by the Rewrite-Engine to Phalcon, you can also use $_SERVER['REQUEST_URI'] if required:

<?php

use Phalcon\Mvc\Router;

// ...

$router->setUriSource(Router::URI_SOURCE_GET_URL); // Use $_GET['_url'] (default)
$router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI); // Use $_SERVER['REQUEST_URI'] (default)

Or you can manually pass a URI to the handle() method:

<?php

$router->handle('/some/route/to/handle');

测试路由（Testing your routes）¶

Since this component has no dependencies, you can create a file as shown below to test your routes:

<?php

use Phalcon\Mvc\Router;

// These routes simulate real URIs
$testRoutes = array(
    '/',
    '/index',
    '/index/index',
    '/index/test',
    '/products',
    '/products/index/',
    '/products/show/101',
);

$router = new Router();

// Add here your custom routes
// ...

// Testing each route
foreach ($testRoutes as $testRoute) {

    // Handle the route
    $router->handle($testRoute);

    echo 'Testing ', $testRoute, '<br>';

    // Check if some route was matched
    if ($router->wasMatched()) {
        echo 'Controller: ', $router->getControllerName(), '<br>';
        echo 'Action: ', $router->getActionName(), '<br>';
    } else {
        echo 'The route wasn\'t matched by any route<br>';
    }

    echo '<br>';
}

注解路由（Annotations Router）¶

这个组件利用集成的注解服务 annotations 提供了一个路由定义的变体。通过这个策略，你可以直接在书写控制器的时候编写路由，而不需要一个一个在服务注册的时候添加。

<?php

use Phalcon\Mvc\Router\Annotations as RouterAnnotations;

$di['router'] = function () {

    // Use the annotations router. We're passing false as we don't want the router to add its default patterns
    $router = new RouterAnnotations(false);

    // Read the annotations from ProductsController if the URI starts with /api/products
    $router->addResource('Products', '/api/products');

    return $router;
};

注解通过如下的方式定义：

<?php

/**
 * @RoutePrefix("/api/products")
 */
class ProductsController
{
    /**
     * @Get("/")
     */
    public function indexAction()
    {

    }

    /**
     * @Get("/edit/{id:[0-9]+}", name="edit-robot")
     */
    public function editAction($id)
    {

    }

    /**
     * @Route("/save", methods={"POST", "PUT"}, name="save-robot")
     */
    public function saveAction()
    {

    }

    /**
     * @Route("/delete/{id:[0-9]+}", methods="DELETE",
     *      conversors={id="MyConversors::checkId"})
     */
    public function deleteAction($id)
    {

    }

    public function infoAction($id)
    {

    }
}

只有标记了格式正确的注解的方法才能被用作路由。Phalcon支持如下注解：

名称	描述	用法
RoutePrefix	A prefix to be prepended to each route URI. This annotation must be placed at the class’ docblock	@RoutePrefix(“/api/products”)
Route	This annotation marks a method as a route. This annotation must be placed in a method docblock	@Route(“/api/products/show”)
Get	This annotation marks a method as a route restricting the HTTP method to GET	@Get(“/api/products/search”)
Post	This annotation marks a method as a route restricting the HTTP method to POST	@Post(“/api/products/save”)
Put	This annotation marks a method as a route restricting the HTTP method to PUT	@Put(“/api/products/save”)
Delete	This annotation marks a method as a route restricting the HTTP method to DELETE	@Delete(“/api/products/delete/{id}”)
Options	This annotation marks a method as a route restricting the HTTP method to OPTIONS	@Option(“/api/products/info”)

用来添加路由的注解支持如下参数：

名称	描述	用法
methods	Define one or more HTTP method that route must meet with	@Route(“/api/products”, methods={“GET”, “POST”})
name	Define a name for the route	@Route(“/api/products”, name=”get-products”)
paths	An array of paths like the one passed to `Phalcon\Mvc\Router::add()`	@Route(“/posts/{id}/{slug}”, paths={module=”backend”})
conversors	A hash of conversors to be applied to the parameters	@Route(“/posts/{id}/{slug}”, conversors={id=”MyConversor::getId”})

如果路由对应的控制器属于一个模块，使用 addModuleResource() 效果更佳：

<?php

use Phalcon\Mvc\Router\Annotations as RouterAnnotations;

$di['router'] = function () {

    // Use the annotations router
    $router = new RouterAnnotations(false);

    // Read the annotations from Backend\Controllers\ProductsController if the URI starts with /api/products
    $router->addModuleResource('backend', 'Products', '/api/products');

    return $router;
};

设置 URL 生成器（Setting URL Generator）¶

URL 生成器，帮助 URL 组件生成 URL，例子：

<?php

$route = $router->add("/posts/{year}/{title}", "Posts::show");
$route->setName("blog-post")->setUrlGenerator(function($base_uri, $paths, $uri){
    return $base_uri.'posts/'.$uri['year'].'-'.$uri['title'].'.html';
});
$url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));

注册路由实例（Registering Router instance）¶

You can register router during service registration with Phalcon dependency injector to make it available inside the controllers.

You need to add code below in your bootstrap file (for example index.php or app/config/services.php if you use Phalcon Developer Tools)

<?php

/**
 * Add routing capabilities
 */
$di->set(
    'router',
    function () {
        require __DIR__.'/../app/config/routes.php';

        return $router;
    }
);

You need to create app/config/routes.php and add router initialization code, for example:

<?php

use Phalcon\Mvc\Router;

$router = new Router();

$router->add(
    "/login",
    array(
        'controller' => 'login',
        'action'     => 'index'
    )
);

$router->add(
    "/products/:action",
    array(
        'controller' => 'products',
        'action'     => 1
    )
);

return $router;

REST 模式（REST Mode）¶

当设置路由为 REST 模式时，会自动将 HTTP method 的值追加到 action 上：

<?php

$router = new Phalcon\Mvc\Router();
$router->setMode(Phalcon\Router::MODE_REST);

$_SERVER['REQUEST_METHOD'] = 'POST';
$router->handle('/posts/info');

echo $router->getActionName(); // 这里将输出 infoPost，如果不开启 REST 模式，将返回 info

自定义路由（Implementing your own Router）¶

The Phalcon\Mvc\RouterInterface interface must be implemented to create your own router replacing the one provided by Phalcon.