关闭

yii 路由

标签: parametersurlstringpathfunctionapplication
8700人阅读 评论(0) 收藏 举报
分类:
http://localhost/testwebap/index.php?r=testmod/default/index。根据以前的知识,我们知道此url是访问的testmod module的default controller下的index action。
对应的存储路径是:
01 ├── protected 
02 │   ├── modules 
03 │   │   └── testmod 
04 │   │       ├── components 
05 │   │       ├── controllers 
06 │   │       │   └── DefaultController.php 
07 │   │       ├── messages 
08 │   │       ├── models 
09 │   │       ├── TestmodModule.php 
10 │   │       └── views 
11 │   │           ├── default 
12 │   │           │   └── index.php
这里我们把testmod/default/index叫做路由。
注意: 默认情况下,路由是大小写敏感的,从版本 1.0.1 开始,可以通过设置应用配置中的CUrlManager::caseSensitive 为 false 使路由对大小写不敏感。当在大小写不敏感模式中时, 要确保你遵循了相应的规则约定,即:包含控制器类文件的目录名小写,且 控制器映射 和 动作映射 中使用的键为小写。
有时候我们可能需要自己定义url,以便创建的url能被框架理解或者有时候框架提供的url格式并不是我们想要的,我们可以自己进行自定义。在YII中,提供了CUrlManager来辅助完成。
来看看CUrlManager,看看如何实现的,以及我们如何使用CUrlManager提供的方法创建我们自己的url。代码放在文档末尾。
通过代码的注释CUrlManager.php,我们可以了解到此类的使用方法。
1. Creating URLs(创建网址)
public function createUrl($route,$params=array(),$ampersand=’&’)
/**
* Constructs a URL.
* @param string $route the controller and the action (e.g. article/read)
* @param array $params list of GET parameters (name=>value). Both the name and value will be URL-encoded.
* If the name is ‘#’, the corresponding value will be treated as an anchor
* and will be appended at the end of the URL. This anchor feature has been available since version 1.0.1.
* @param string $ampersand the token separating name-value pairs in the URL. Defaults to ‘&’.
* @return string the constructed URL
*/
虽然URL可被硬编码在控制器的视图(view)文件,但往往可以很灵活地动态创建它们:
$url=$this->createUrl($route,$params);
$this指的是控制器实例; $route指定请求的route 的要求;$params 列出了附加在网址中的GET参数。
默认情况下,URL以get格式使用createUrl 创建。例如,提供$route=’post/read’和$params=array(’id’=>100) ,我们将获得以下网址:
/index.php?r=post/read&id=100
参数以一系列Name=Value通过符号串联起来出现在请求字符串,r参数指的是请求的route 。这种URL格式用户友好性不是很好,因为它需要一些非字字符。
我们可以使上述网址看起来更简洁,更不言自明,通过采用所谓的’path格式,省去查询字符串和把GET参数加到路径信息,作为网址的一部分:
/index.php/post/read/id/100
要更改URL格式,我们应该配置urlManager应用元件,以便createUrl可以自动切换到新格式和应用程序可以正确理解新的网址:
1 array(
2 ……
3 ‘components’=>array(
4 ……
5 ‘urlManager’=>array(
6 ‘urlFormat’=>’path’,
7 ),
8 ),
9 );
请注意,我们不需要指定的urlManager元件的类,因为它在CWebApplication预声明为CUrlManager。
提示:此网址通过createurl方法所产生的是一个相对地址。为了得到一个绝对的url ,我们可以用前缀yii::app()->hostInfo ,或调用createAbsoluteUrl 。
下面举例子说明用法:
/yii_dev/testwebap/protected/modules/testmod/controllers/DefaultController.php
01 <?php
02
03 class DefaultController extends Controller
04 {
05 public function actionIndex()
06 {
07 $route = ‘post/read’;
08 $params=array(‘id’=>100);
09 $url=$this->createUrl($route,$params);
10 exit($url);
11 $this->render(‘index’);
12 }
13 }
http://localhost/testwebap/index.php?r=testmod/default/index
结果如下:
/testwebap/index.php?r=testmod/post/read&id=100
01 <?php
02
03 class DefaultController extends Controller
04 {
05 public function actionIndex()
06 {
07 $route = ‘post/read’;
08 $params=array(‘id’=>100,‘name’=>‘张三’,‘#’=>‘anchor’);
09 $url=$this->createUrl($route,$params);
10 exit($url);
11 $this->render(‘index’);
12 }
13 }
http://localhost/testwebap/index.php?r=testmod/default/index
结果如下:
/testwebap/index.php?r=testmod/post/read&id=100&name=%E5%BC%A0%E4%B8%89#anchor
2. 自定义格式
具体实例,如下:
配置文件
01 // application components 
02 ‘components’=>array( 
03 ‘user’=>array( 
04 // enable cookie-based authentication 
05 ‘allowAutoLogin’=>true, 
06 ), 
07 ‘urlManager’=>array( 
08 ‘urlFormat’=>’path’, 
09 ‘rules’=>array( 
10 ‘<module:\w+>/<controller:\w+>/<action:\w+>’=>’<module>/<controller>/<action>’,
11 ), 
12 ),
1 <?php
2
3 class DefaultController extends Controller
4 {
5 public function actionIndex()
6 {
7 $this->render(‘index’);
8 }
9 }
访问方式
http://localhost/testwebap/index.php/testmod/default/index
自定义格式的目的提供一个好记简短的单词提供给用户,这种url是对用户有好的。我们称之为user-friendly Urls
3. User-friendly URLs(用户友好的URL)
当用path格式URL,我们可以指定某些URL规则使我们的网址更用户友好性。例如,我们可以产生一个短短的URL/post/100 ,而不是冗长/index.php/post/read/id/100。网址创建和解析都是通过CUrlManager指定网址规则。
配置文件以及路由规则细说:
配置文件
在/yii_dev/testwebap/protected/config/main.php
yii给出的配置demo是
01 /* 
02 ‘urlManager’=>array( 
03 ‘urlFormat’=>’path’, 
04 ‘rules’=>array( 
05 ‘<controller:\w+>/<id:\d+>’=>’<controller>/view’, 
06 ‘<controller:\w+>/<action:\w+>/<id:\d+>’=>’<controller>/<action>’, 
07 ‘<controller:\w+>/<action:\w+>’=>’<controller>/<action>’, 
08 ), 
09 ), 
10 */
urlFromat的值 必须是 “path” 或 “get”.
‘path’ format: /path/to/EntryScript.php/name1/value1/name2/value2…
‘get’ format: /path/to/EntryScript.php?name1=value1&name2=value2…
caseSensitive的值是true false
路由是否区分大小写。
例如
01 // application components 
02 ‘components’=>array( 
03 ‘user’=>array( 
04 // enable cookie-based authentication 
05 ‘allowAutoLogin’=>true, 
06 ), 
07 ‘urlManager’=>array( 
08 ‘caseSensitive’=>false, 
09 ‘urlFormat’=>’path’, 
10 ‘rules’=>array( 
11 ‘<module:\w+>/<controller:\w+>/<action:\w+>/<id:\d+>’=>’<module>/<controller>/<action>’,
12 ‘<module:\w+>/<controller:\w+>/<action:\w+>’=>’<module>/<controller>/<action>’,
13 ), 
14 ),
http://localhost/testwebap/index.php/TESTmod/default/index
urlSuffix
是为路由设置一个后缀名称例如.html
rules的值要求是
1 ‘rules’=>array(
2 ‘pattern1′=>’route1′,
3 ‘pattern2′=>’route2′,
4 ‘pattern3′=>’route3′,
5 ),
array the URL rules (pattern=>route).
路由规则=>路由
要指定的URL规则,我们必须设定urlManager 应用元件的属性rules:
01 array(
02 ……
03 ‘components’=>array(
04 ……
05 ‘urlManager’=>array(
06 ‘urlFormat’=>’path’,
07 ‘rules’=>array(
08 ‘pattern1′=>’route1′,
09 ‘pattern2′=>’route2′,
10 ‘pattern3′=>’route3′,
11 ),
12 ),
13 ),
14 );
这些规则以一系列的路线格式对数组指定,每对对应于一个单一的规则。路线(route)的格式必须是有效的正则表达式,没有分隔符和修饰语。它是用于匹配网址的路径信息部分。还有route应指向一个有效的路线控制器。
规则可以绑定少量的GET参数。这些出现在规则格式的GET参数,以一种特殊令牌格式表现如下:
‘pattern1′=>array(’route1′, ‘urlSuffix’=>’.xml’, ‘caseSensitive’=>false)
In the above, the array contains a list of customized options. As of version 1.1.0, the following options are available:
urlSuffix: the URL suffix used specifically for this rule. Defaults to null, meaning using the value of CUrlManager::urlSuffix.
后缀
caseSensitive: whether this rule is case sensitive. Defaults to null, meaning using the value of CUrlManager::caseSensitive.
是否区分大小写
defaultParams: the default GET parameters (name=>value) that this rule provides. When this rule is used to parse the incoming request, the values declared in this property will be injected into $_GET.
提供默认的get参数值
matchValue: whether the GET parameter values should match the corresponding sub-patterns in the rule when creating a URL. Defaults to null, meaning using the value of CUrlManager::matchValue. If this property is false, it means a rule will be used for creating a URL if its route and parameter names match the given ones. If this property is set true, then the given parameter values must also match the corresponding parameter sub-patterns. Note that setting this property to true will degrade performance.
GET参数值是否应匹配相应的规则中的子模式,创建一个URL时。默认为null,这意味着使用CUrlManager的matchValue。如果此属性为false,这意味着将按照它的路线和参数名称匹配的规则创建一个URL。如果此属性设置为true,给定的参数值也必须符合相应的参数子模式。请注意,此属性设置为true会降低性能。
Using Named Parameters(使用命名参数)
A rule can be associated with a few GET parameters. These GET parameters appear in the rule’s pattern as special tokens in the following format:
一个规则可以有多个GET参数。这些GET参数可以通过特殊的参数令牌来对号入座。格式如下:
ParamName表示GET参数名字,
可选项ParamPattern表示将用于匹配GET参数值的正则表达式。
当生成一个网址(URL)时,这些参数令牌将被相应的参数值替换;
当解析一个网址时,相应的GET参数将通过解析结果来生成。
我们使用一些例子来解释网址工作规则。我们假设我们的规则包括如下三个:
array(
    ‘posts‘=>‘post/list‘,
    ‘post/<id:\d+>‘=>‘post/read‘,
    ‘post/<year:\d{4}>/<title>‘=>‘post/read‘,
)
调用$this->createUrl('post/list')生成/index.php/posts。第一个规则适用。
调用$this->createUrl('post/read',array('id'=>100))生成/index.php/post/100。第二个规则适用。
调用$this->createUrl('post/read',array('year'=>2008,'title'=>'a sample post'))生成/index.php/post/2008/a%20sample%20post。第三个规则适用。
调用$this->createUrl('post/read')产生/index.php/post/read。请注意,没有规则适用。
总之,当使用createUrl生成网址,路线和传递给该方法的GET参数被用来决定哪些网址规则适用。如果关联规则中的每个参数可以在GET参数找到的,将被传递给createUrl ,如果路线的规则也匹配路线参数,规则将用来生成网址。
如果GET参数传递到createUrl是以上所要求的一项规则,其他参数将出现在查询字符串。
例如,如果我们调用$this->createUrl('post/read',array('id'=>100,'year'=>2008)) ,我们将获得/index.php/post/100?year=2008。为了使这些额外参数出现在路径信息的一部分,我们应该给规则附加/*。 因此,该规则post/<id:\d+>/* ,我们可以获取网址/index.php/post/100/year/2008 。
正如我们提到的,URL规则的其他用途是解析请求网址。当然,这是URL生成的一个逆过程。例如, 当用户请求/index.php/post/100 ,上面例子的第二个规则将适用来解析路线post/read和GET参数array('id'=>100) (可通过$_GET获得) 。
注:使用的URL规则将降低应用的性能。这是因为当解析请求的URL ,[ CUrlManager ]尝试使用每个规则来匹配它,直到某个规则可以适用。因此,高流量网站应用应尽量减少其使用的URL规则。
Parameterizing Routes路由参数
Starting from version 1.0.5, we may reference named parameters in the route part of a rule. This allows a rule to be applied to multiple routes based on matching criteria. It may also help reduce the number of rules needed for an application, and thus improve the overall performance.
从版本1.0.5开始,我们可能在一个路由规则中使用参数令牌。这样可以允许一个规则可以匹配多个路由。 有助于减少应用程序所需的规则的数量,从而提高整体性能。
We use the following example rules to illustrate how to parameterize routes with named parameters:
我们用下面的例子来说明如何使用:
array(
    ‘<_c:(post|comment)>/<id:\d+>/<_a:(create|update|delete)>‘ => ‘<_c>/<_a>‘,
    ‘<_c:(post|comment)>/<id:\d+>‘ => ‘<_c>/read‘,
    ‘<_c:(post|comment)>s‘ => ‘<_c>/list‘,
)
In the above, we use two named parameters in the route part of the rules: _c and _a. The former matches a controller ID to be either post or comment, while the latter matches an action ID to be create, update or delete. You may name the parameters differently as long as they do not conflict with GET parameters that may appear in URLs.
在上面,我们使用了两种命名参数:_c和_a。前者相匹配的controllerID,要么 post 要么是 comment,而后者相匹配的actionID是create, update 或者 delete。
您可能随便定义参数的名称,只要他们不冲突即不会在网址的中出现即可。
Using the aboving rules, the URL /index.php/post/123/create would be parsed as the route post/create with GET parameter id=123. And given the route comment/list and GET parameter page=2, we can create a URL /index.php/comments?page=2.
使用上面的规则,
使用/ index.php/post/123/create会被解析为 post/create路由,GET参数id= 123。
使用/index.php/comments?page=2.会被解析为 comment/list 和get参数page= 2
Parameterizing Hostnames主机参数
Starting from version 1.0.11, it is also possible to include hostname into the rules for parsing and creating URLs. One may extract part of the hostname to be a GET parameter. For example, the URL http://admin.example.com/en/profile may be parsed into GET parameters user=admin and lang=en. On the other hand, rules with hostname may also be used to create URLs with paratermized hostnames.
从版本1.0.11开始,路由规则中也可能包括主机名。将主机的名称作为get参数的一部分。例如, http://admin.example.com/en/profile可能被解析成 user=admin and lang=en。
另一方面,主机名的规则也可能被用来创建URL。
In order to use parameterized hostnames, simply declare URL rules with host info, e.g.:
array(
    ‘http://<user:\w+>.example.com/<lang:\w+>/profile‘ => ‘user/profile‘,
)
The above example says that the first segment in the hostname should be treated as userparameter while the first segment in the path info should be lang parameter. The rule corresponds to the user/profile route.
上面的例子中,其中的url路径中的user、lang可以被解析成get参数的user和lang。该规则对应的路由是user/profile。
Note that CUrlManager::showScriptName will not take effect when a URL is being created using a rule with parameterized hostname.
注意如果在路由规则包含主机参数, CUrlManager::showScriptName 将不会有效。
Also note that the rule with parameterized hostname should NOT contain the sub-folder if the application is under a sub-folder of the Web root. For example, if the application is under http://www.example.com/sandbox/blog, then we should still use the same URL rule as described above without the sub-folder sandbox/blog.
还要注意的是主机参数的规则不应该包含的子文件夹,如果应用程序是一个子文件夹中的Web根下。例如,如果应用程序是根据http://www.example.com/sandbox/blog,那么我们使用上述URL规则解析sandbox/blog将不会得到正确的结果。
4. 隐藏 index.php
还有一点,我们可以做进一步清理我们的网址,即在URL中藏匿index.php入口脚本。这就要求我们配置Web服务器,以及urlManager应用程序元件。
我们首先需要配置Web服务器,这样一个URL没有入口脚本仍然可以处理入口脚本。如果是Apache HTTP server,可以通过打开网址重写引擎和指定一些重写规则。这两个操作可以在包含入口脚本的目录下的.htaccess文件里实现。下面是一个示例:
Options +FollowSymLinks
IndexIgnore */*
RewriteEngine on


# if a directory or a file exists, use it directly
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d


# otherwise forward it to index.php
RewriteRule . index.php
然后,我们设定urlManager元件的showScriptName属性为 false。
现在,如果我们调用$this->createUrl('post/read',array('id'=>100)) ,我们将获取网址/post/100。更重要的是,这个URL可以被我们的Web应用程序正确解析。
http://www.localyii.com/testwebap/site/login
.htaccess
[plain] view plaincopy


options +FollowSymLinks
IndexIgnore */*
RewriteEngine on
# if a directory or a file exists, use it directly
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
# otherwise forward it to index.php
RewriteRule . index.php
apache.conf
[plain] view plaincopy


<VirtualHost *:80>
ServerAdmin webmaster@localhost
ServerName  www.localyii.com
ServerAlias www.localyii.com
DocumentRoot /home/coder/adata/liuyuqiang/wamp/www/yii_dev
<Directory /home/coder/adata/liuyuqiang/wamp/www/yii_dev>
Options FollowSymLinks
AllowOverride  All
</Directory>
</VirtualHost>
必须是
[plain] view plaincopy


AllowOverride  All
apache必须安装了rewrite模块
5.Faking URL Suffix(伪造URL后缀)
上面已经说过我们可以添加一些网址的后缀。例如,我们可以用/post/100.html来替代/post/100 。这使得它看起来更像一个静态网页URL。为了做到这一点,只需配置urlManager元件的urlSuffix属性为你所喜欢的后缀。这里不再举例说明。
6. 使用自定义URL规则设置类 
注意: Yii从1.1.8版本起支持自定义URL规则类
默认情况下,每个URL规则都通过CUrlManager来声明为一个CUrlRule对象,这个对象会解析当前请求并根据具体的规则来生成URL。 虽然CUrlRule可以处理大部分URL格式,但在某些特殊情况下仍旧有改进余地。
比如,在一个汽车销售网站上,可能会需要支持类似/Manufacturer/Model这样的URL格式, 其中Manufacturer 和 Model 都各自对应数据库中的一个表。此时CUrlRule就无能为力了。
我们可以通过继承CUrlRule的方式来创造一个新的URL规则类。并且使用这个类解析一个或者多个规则。 以上面提到的汽车销售网站为例,我们可以声明下面的URL规则。
array(
    // 一个标准的URL规则,将 ‘/’ 对应到 ’site/index’
    ‘‘ => ‘site/index‘,


    // 一个标准的URL规则,将 ‘/login’ 对应到 ’site/login’, 等等
    ‘<action:(login|logout|about)>‘ => ‘site/<action>‘,


    // 一个自定义URL规则,用来处理 ‘/Manufacturer/Model’
    array(
        ‘class‘ => ‘application.components.CarUrlRule‘,
        ‘connectionID‘ => ‘db‘,
    ),


    // 一个标准的URL规则,用来处理 ‘post/update’ 等
    ‘<controller:\w+>/<action:\w+>‘ => ‘<controller>/<action>‘,
),
从以上可以看到,我们自定义了一个URL规则类CarUrlRule来处理类似/Manufacturer/Model这样的URL规则。 这个类可以这么写:
class CarUrlRule extends CBaseUrlRule
{
    public $connectionID = ‘db‘;


    public function createUrl($manager,$route,$params,$ampersand)
    {
        if ($route===‘car/index‘)
        {
            if (isset($params['manufacturer'], $params['model']))
                return $params['manufacturer'] . ‘/‘ . $params['model'];
            else if (isset($params['manufacturer']))
                return $params['manufacturer'];
        }
        return false;  // this rule does not apply
    }


    public function parseUrl($manager,$request,$pathInfo,$rawPathInfo)
    {
        if (preg_match(‘%^(\w+)(/(\w+))?$%‘, $pathInfo, $matches))
        {
            // check $matches[1] and $matches[3] to see
            // if they match a manufacturer and a model in the database
            // If so, set $_GET['manufacturer'] and/or $_GET['model']
            // and return ‘car/index’
        }
        return false;  // this rule does not apply
    }
}
自定义URL规则类必须实现在CBaseUrlRule中定义的两个接口。
[CBaseUrlRule::createUrl()|createUrl()]
[CBaseUrlRule::parseUrl()|parseUrl()]
除了这种典型用法,自定义URL规则类还可以有其他的用途。比如,我们可以写一个规则类来记录有关URL解析和UEL创建的请求。 这对于正在开发中的网站来说很有用。我们还可以写一个规则类来在其他URL规则都匹配失败的时候显示一个自定义404页面。 注意,这种用法要求规则类在所有其他规则的最后声明。
记住,隐藏index.php.
然后配置文件中使用如下:
[php] view plaincopy


‘urlManager’=>array(
‘caseSensitive’=>false,
‘urlFormat’=>‘path’,
‘rules’=>array(
),
),
你的地址栏就已经非常完美,非常清净。你不用去考虑定义烦人的url,不用使用让你恼怒的rule。一样可以赢得用户的心,得到搜索引擎的力挺。
/////////////////////////////代码区域///////////////////////////////////
CUrlManager.php
[php] view plaincopy


<?php
/**
* CUrlManager class file
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright Copyright © 2008-2011 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CUrlManager manages the URLs of Yii Web applications.
*
* It provides URL construction ({@link createUrl()}) as well as parsing ({@link parseUrl()}) functionality.
*
* URLs managed via CUrlManager can be in one of the following two formats,
* by setting {@link setUrlFormat urlFormat} property:
* <ul>
* <li>’path’ format: /path/to/EntryScript.php/name1/value1/name2/value2…</li>
* <li>’get’ format:  /path/to/EntryScript.php?name1=value1&name2=value2…</li>
* </ul>
*
* When using ’path’ format, CUrlManager uses a set of {@link setRules rules} to:
* <ul>
* <li>parse the requested URL into a route (’ControllerID/ActionID’) and GET parameters;</li>
* <li>create URLs based on the given route and GET parameters.</li>
* </ul>
*
* A rule consists of a route and a pattern. The latter is used by CUrlManager to determine
* which rule is used for parsing/creating URLs. A pattern is meant to match the path info
* part of a URL. It may contain named parameters using the syntax ’<ParamName:RegExp>’.
*
* When parsing a URL, a matching rule will extract the named parameters from the path info
* and put them into the $_GET variable; when creating a URL, a matching rule will extract
* the named parameters from $_GET and put them into the path info part of the created URL.
*
* If a pattern ends with ’/*’, it means additional GET parameters may be appended to the path
* info part of the URL; otherwise, the GET parameters can only appear in the query string part.
*
* To specify URL rules, set the {@link setRules rules} property as an array of rules (pattern=>route).
* For example,
* <pre>
* array(
*     ’articles’=>’article/list’,
*     ’article/<id:\d+>/*’=>’article/read’,
* )
* </pre>
* Two rules are specified in the above:
* <ul>
* <li>The first rule says that if the user requests the URL ’/path/to/index.php/articles’,
*   it should be treated as ’/path/to/index.php/article/list’; and vice versa applies
*   when constructing such a URL.</li>
* <li>The second rule contains a named parameter ’id’ which is specified using
*   the <ParamName:RegExp> syntax. It says that if the user requests the URL
*   ’/path/to/index.php/article/13′, it should be treated as ’/path/to/index.php/article/read?id=13′;
*   and vice versa applies when constructing such a URL.</li>
* </ul>
*
* Starting from version 1.0.5, the route part may contain references to named parameters defined
* in the pattern part. This allows a rule to be applied to different routes based on matching criteria.
* For example,
* <pre>
* array(
*      ’<_c:(post|comment)>/<id:\d+>/<_a:(create|update|delete)>’=>’<_c>/<_a>’,
*      ’<_c:(post|comment)>/<id:\d+>’=>’<_c>/view’,
*      ’<_c:(post|comment)>s/*’=>’<_c>/list’,
* )
* </pre>
* In the above, we use two named parameters ’<_c>’ and ’<_a>’ in the route part. The ’<_c>’
* parameter matches either ’post’ or ’comment’, while the ’<_a>’ parameter matches an action ID.
*
* Like normal rules, these rules can be used for both parsing and creating URLs.
* For example, using the rules above, the URL ’/index.php/post/123/create’
* would be parsed as the route ’post/create’ with GET parameter ’id’ being 123.
* And given the route ’post/list’ and GET parameter ’page’ being 2, we should get a URL
* ’/index.php/posts/page/2′.
*
* Starting from version 1.0.11, it is also possible to include hostname into the rules
* for parsing and creating URLs. One may extract part of the hostname to be a GET parameter.
* For example, the URL <code>http://admin.example.com/en/profile</code> may be parsed into GET parameters
* <code>user=admin</code> and <code>lang=en</code>. On the other hand, rules with hostname may also be used to
* create URLs with parameterized hostnames.
*
* In order to use parameterized hostnames, simply declare URL rules with host info, e.g.:
* <pre>
* array(
*     ’http://<user:\w+>.example.com/<lang:\w+>/profile’ => ’user/profile’,
* )
* </pre>
*
* Starting from version 1.1.8, one can write custom URL rule classes and use them for one or several URL rules.
* For example,
* <pre>
* array(
*   // a standard rule
*   ’<action:(login|logout)>’ => ’site/<action>’,
*   // a custom rule using data in DB
*   array(
*     ’class’ => ’application.components.MyUrlRule’,
*     ’connectionID’ => ’db’,
*   ),
* )
* </pre>
* Please note that the custom URL rule class should extend from {@link CBaseUrlRule} and
* implement the following two methods,
* <ul>
*    <li>{@link CBaseUrlRule::createUrl()}</li>
*    <li>{@link CBaseUrlRule::parseUrl()}</li>
* </ul>
*
* CUrlManager is a default application component that may be accessed via
* {@link CWebApplication::getUrlManager()}.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @version $Id: CUrlManager.php 3237 2011-05-25 13:13:26Z qiang.xue $
* @package system.web
* @since 1.0
*/
class CUrlManager extends CApplicationComponent
{
const CACHE_KEY=‘Yii.CUrlManager.rules’;
const GET_FORMAT=‘get’;
const PATH_FORMAT=‘path’;
/**
* @var array the URL rules (pattern=>route).
*/
public $rules=array();
/**
* @var string the URL suffix used when in ’path’ format.
* For example, ”.html” can be used so that the URL looks like pointing to a static HTML page. Defaults to empty.
*/
public $urlSuffix=”;
/**
* @var boolean whether to show entry script name in the constructed URL. Defaults to true.
*/
public $showScriptName=true;
/**
* @var boolean whether to append GET parameters to the path info part. Defaults to true.
* This property is only effective when {@link urlFormat} is ’path’ and is mainly used when
* creating URLs. When it is true, GET parameters will be appended to the path info and
* separate from each other using slashes. If this is false, GET parameters will be in query part.
* @since 1.0.3
*/
public $appendParams=true;
/**
* @var string the GET variable name for route. Defaults to ’r’.
*/
public $routeVar=‘r’;
/**
* @var boolean whether routes are case-sensitive. Defaults to true. By setting this to false,
* the route in the incoming request will be turned to lower case first before further processing.
* As a result, you should follow the convention that you use lower case when specifying
* controller mapping ({@link CWebApplication::controllerMap}) and action mapping
* ({@link CController::actions}). Also, the directory names for organizing controllers should
* be in lower case.
* @since 1.0.1
*/
public $caseSensitive=true;
/**
* @var boolean whether the GET parameter values should match the corresponding
* sub-patterns in a rule before using it to create a URL. Defaults to false, meaning
* a rule will be used for creating a URL only if its route and parameter names match the given ones.
* If this property is set true, then the given parameter values must also match the corresponding
* parameter sub-patterns. Note that setting this property to true will degrade performance.
* @since 1.1.0
*/
public $matchValue=false;
/**
* @var string the ID of the cache application component that is used to cache the parsed URL rules.
* Defaults to ’cache’ which refers to the primary cache application component.
* Set this property to false if you want to disable caching URL rules.
* @since 1.0.3
*/
public $cacheID=‘cache’;
/**
* @var boolean whether to enable strict URL parsing.
* This property is only effective when {@link urlFormat} is ’path’.
* If it is set true, then an incoming URL must match one of the {@link rules URL rules}.
* Otherwise, it will be treated as an invalid request and trigger a 404 HTTP exception.
* Defaults to false.
* @since 1.0.6
*/
public $useStrictParsing=false;
/**
* @var string the class name or path alias for the URL rule instances. Defaults to ’CUrlRule’.
* If you change this to something else, please make sure that the new class must extend from
* {@link CBaseUrlRule} and have the same constructor signature as {@link CUrlRule}.
* It must also be serializable and autoloadable.
* @since 1.1.8
*/
public $urlRuleClass=‘CUrlRule’;
private $_urlFormat=self::GET_FORMAT;
private $_rules=array();
private $_baseUrl;
/**
* Initializes the application component.
*/
public function init()
{
parent::init();
$this->processRules();
}
/**
* Processes the URL rules.
*/
protected function processRules()
{
if(emptyempty($this->rules) || $this->getUrlFormat()===self::GET_FORMAT)
return;
if($this->cacheID!==false && ($cache=Yii::app()->getComponent($this->cacheID))!==null)
{
$hash=md5(serialize($this->rules));
if(($data=$cache->get(self::CACHE_KEY))!==false && isset($data[1]) && $data[1]===$hash)
{
$this->_rules=$data[0];
return;
}
}
foreach($this->rules as $pattern=>$route)
$this->_rules[]=$this->createUrlRule($route,$pattern);
if(isset($cache))
$cache->set(self::CACHE_KEY,array($this->_rules,$hash));
}
/**
* Adds new URL rules.
* In order to make the new rules effective, this method must be called BEFORE
* {@link CWebApplication::processRequest}.
* @param array $rules new URL rules (pattern=>route).
* @since 1.1.4
*/
public function addRules($rules)
{
foreach($rules as $pattern=>$route)
$this->_rules[]=$this->createUrlRule($route,$pattern);
}
/**
* Creates a URL rule instance.
* The default implementation returns a CUrlRule object.
* @param mixed $route the route part of the rule. This could be a string or an array
* @param string $pattern the pattern part of the rule
* @return CUrlRule the URL rule instance
* @since 1.1.0
*/
protected function createUrlRule($route,$pattern)
{
if(is_array($route) && isset($route['class']))
return $route;
else
return new $this->urlRuleClass($route,$pattern);
}
/**
* Constructs a URL.
* @param string $route the controller and the action (e.g. article/read)
* @param array $params list of GET parameters (name=>value). Both the name and value will be URL-encoded.
* If the name is ’#', the corresponding value will be treated as an anchor
* and will be appended at the end of the URL. This anchor feature has been available since version 1.0.1.
* @param string $ampersand the token separating name-value pairs in the URL. Defaults to ’&’.
* @return string the constructed URL
*/
public function createUrl($route,$params=array(),$ampersand=‘&’)
{
unset($params[$this->routeVar]);
foreach($params as &$param)
if($param===null)
$param=”;
if(isset($params['#']))
{
$anchor=‘#’.$params['#'];
unset($params['#']);
}
else
$anchor=”;
$route=trim($route,‘/’);
foreach($this->_rules as $i=>$rule)
{
if(is_array($rule))
$this->_rules[$i]=$rule=Yii::createComponent($rule);
if(($url=$rule->createUrl($this,$route,$params,$ampersand))!==false)
{
if($rule->hasHostInfo)
return $url===” ? ‘/’.$anchor : $url.$anchor;
else
return $this->getBaseUrl().‘/’.$url.$anchor;
}
}
return $this->createUrlDefault($route,$params,$ampersand).$anchor;
}
/**
* Creates a URL based on default settings.
* @param string $route the controller and the action (e.g. article/read)
* @param array $params list of GET parameters
* @param string $ampersand the token separating name-value pairs in the URL.
* @return string the constructed URL
*/
protected function createUrlDefault($route,$params,$ampersand)
{
if($this->getUrlFormat()===self::PATH_FORMAT)
{
$url=rtrim($this->getBaseUrl().‘/’.$route,‘/’);
if($this->appendParams)
{
$url=rtrim($url.‘/’.$this->createPathInfo($params,‘/’,‘/’),‘/’);
return $route===” ? $url : $url.$this->urlSuffix;
}
else
{
if($route!==”)
$url.=$this->urlSuffix;
$query=$this->createPathInfo($params,‘=’,$ampersand);
return $query===” ? $url : $url.‘?’.$query;
}
}
else
{
$url=$this->getBaseUrl();
if(!$this->showScriptName)
$url.=‘/’;
if($route!==”)
{
$url.=‘?’.$this->routeVar.‘=’.$route;
if(($query=$this->createPathInfo($params,‘=’,$ampersand))!==”)
$url.=$ampersand.$query;
}
else if(($query=$this->createPathInfo($params,‘=’,$ampersand))!==”)
$url.=‘?’.$query;
return $url;
}
}
/**
* Parses the user request.
* @param CHttpRequest $request the request application component
* @return string the route (controllerID/actionID) and perhaps GET parameters in path format.
*/
public function parseUrl($request)
{
if($this->getUrlFormat()===self::PATH_FORMAT)
{
$rawPathInfo=$request->getPathInfo();
$pathInfo=$this->removeUrlSuffix($rawPathInfo,$this->urlSuffix);
foreach($this->_rules as $i=>$rule)
{
if(is_array($rule))
$this->_rules[$i]=$rule=Yii::createComponent($rule);
if(($r=$rule->parseUrl($this,$request,$pathInfo,$rawPathInfo))!==false)
return isset($_GET[$this->routeVar]) ? $_GET[$this->routeVar] : $r;
}
if($this->useStrictParsing)
throw new CHttpException(404,Yii::t(‘yii’,‘Unable to resolve the request ”{route}”.’,
array(‘{route}’=>$pathInfo)));
else
return $pathInfo;
}
else if(isset($_GET[$this->routeVar]))
return $_GET[$this->routeVar];
else if(isset($_POST[$this->routeVar]))
return $_POST[$this->routeVar];
else
return ”;
}
/**
* Parses a path info into URL segments and saves them to $_GET and $_REQUEST.
* @param string $pathInfo path info
* @since 1.0.3
*/
public function parsePathInfo($pathInfo)
{
if($pathInfo===”)
return;
$segs=explode(‘/’,$pathInfo.‘/’);
$n=count($segs);
for($i=0;$i<$n-1;$i+=2)
{
$key=$segs[$i];
if($key===”) continue;
$value=$segs[$i+1];
if(($pos=strpos($key,‘['))!==false && ($m=preg_match_all('/\[(.*?)\]/’,$key,$matches))>0)
{
$name=substr($key,0,$pos);
for($j=$m-1;$j>=0;–$j)
{
if($matches[1][$j]===”)
$value=array($value);
else
$value=array($matches[1][$j]=>$value);
}
if(isset($_GET[$name]) && is_array($_GET[$name]))
$value=CMap::mergeArray($_GET[$name],$value);
$_REQUEST[$name]=$_GET[$name]=$value;
}
else
$_REQUEST[$key]=$_GET[$key]=$value;
}
}
/**
* Creates a path info based on the given parameters.
* @param array $params list of GET parameters
* @param string $equal the separator between name and value
* @param string $ampersand the separator between name-value pairs
* @param string $key this is used internally.
* @return string the created path info
* @since 1.0.3
*/
public function createPathInfo($params,$equal,$ampersand, $key=null)
{
$pairs = array();
foreach($params as $k => $v)
{
if ($key!==null)
$k = $key.‘['.$k.']‘;
if (is_array($v))
$pairs[]=$this->createPathInfo($v,$equal,$ampersand, $k);
else
$pairs[]=urlencode($k).$equal.urlencode($v);
}
return implode($ampersand,$pairs);
}
/**
* Removes the URL suffix from path info.
* @param string $pathInfo path info part in the URL
* @param string $urlSuffix the URL suffix to be removed
* @return string path info with URL suffix removed.
*/
public function removeUrlSuffix($pathInfo,$urlSuffix)
{
if($urlSuffix!==” && substr($pathInfo,-strlen($urlSuffix))===$urlSuffix)
return substr($pathInfo,0,-strlen($urlSuffix));
else
return $pathInfo;
}
/**
* Returns the base URL of the application.
* @return string the base URL of the application (the part after host name and before query string).
* If {@link showScriptName} is true, it will include the script name part.
* Otherwise, it will not, and the ending slashes are stripped off.
*/
public function getBaseUrl()
{
if($this->_baseUrl!==null)
return $this->_baseUrl;
else
{
if($this->showScriptName)
$this->_baseUrl=Yii::app()->getRequest()->getScriptUrl();
else
$this->_baseUrl=Yii::app()->getRequest()->getBaseUrl();
return $this->_baseUrl;
}
}
/**
* Sets the base URL of the application (the part after host name and before query string).
* This method is provided in case the {@link baseUrl} cannot be determined automatically.
* The ending slashes should be stripped off. And you are also responsible to remove the script name
* if you set {@link showScriptName} to be false.
* @param string $value the base URL of the application
* @since 1.1.1
*/
public function setBaseUrl($value)
{
$this->_baseUrl=$value;
}
/**
* Returns the URL format.
* @return string the URL format. Defaults to ’path’. Valid values include ’path’ and ’get’.
* Please refer to the guide for more details about the difference between these two formats.
*/
public function getUrlFormat()
{
return $this->_urlFormat;
}
/**
* Sets the URL format.
* @param string $value the URL format. It must be either ’path’ or ’get’.
*/
public function setUrlFormat($value)
{
if($value===self::PATH_FORMAT || $value===self::GET_FORMAT)
$this->_urlFormat=$value;
else
throw new CException(Yii::t(‘yii’,‘CUrlManager.UrlFormat must be either ”path” or ”get”.’));
}
}
/**
* CBaseUrlRule is the base class for a URL rule class.
*
* Custom URL rule classes should extend from this class and implement two methods:
* {@link createUrl} and {@link parseUrl}.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @version $Id: CUrlManager.php 3237 2011-05-25 13:13:26Z qiang.xue $
* @package system.web
* @since 1.1.8
*/
abstract class CBaseUrlRule extends CComponent
{
/**
* @var boolean whether this rule will also parse the host info part. Defaults to false.
*/
public $hasHostInfo=false;
/**
* Creates a URL based on this rule.
* @param CUrlManager $manager the manager
* @param string $route the route
* @param array $params list of parameters (name=>value) associated with the route
* @param string $ampersand the token separating name-value pairs in the URL.
* @return mixed the constructed URL. False if this rule does not apply.
*/
abstract public function createUrl($manager,$route,$params,$ampersand);
/**
* Parses a URL based on this rule.
* @param CUrlManager $manager the URL manager
* @param CHttpRequest $request the request object
* @param string $pathInfo path info part of the URL (URL suffix is already removed based on {@link CUrlManager::urlSuffix})
* @param string $rawPathInfo path info that contains the potential URL suffix
* @return mixed the route that consists of the controller ID and action ID. False if this rule does not apply.
*/
abstract public function parseUrl($manager,$request,$pathInfo,$rawPathInfo);
}
/**
* CUrlRule represents a URL formatting/parsing rule.
*
* It mainly consists of two parts: route and pattern. The former classifies
* the rule so that it only applies to specific controller-action route.
* The latter performs the actual formatting and parsing role. The pattern
* may have a set of named parameters.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @version $Id: CUrlManager.php 3237 2011-05-25 13:13:26Z qiang.xue $
* @package system.web
* @since 1.0
*/
class CUrlRule extends CBaseUrlRule
{
/**
* @var string the URL suffix used for this rule.
* For example, ”.html” can be used so that the URL looks like pointing to a static HTML page.
* Defaults to null, meaning using the value of {@link CUrlManager::urlSuffix}.
* @since 1.0.6
*/
public $urlSuffix;
/**
* @var boolean whether the rule is case sensitive. Defaults to null, meaning
* using the value of {@link CUrlManager::caseSensitive}.
* @since 1.0.1
*/
public $caseSensitive;
/**
* @var array the default GET parameters (name=>value) that this rule provides.
* When this rule is used to parse the incoming request, the values declared in this property
* will be injected into $_GET.
* @since 1.0.8
*/
public $defaultParams=array();
/**
* @var boolean whether the GET parameter values should match the corresponding
* sub-patterns in the rule when creating a URL. Defaults to null, meaning using the value
* of {@link CUrlManager::matchValue}. When this property is false, it means
* a rule will be used for creating a URL if its route and parameter names match the given ones.
* If this property is set true, then the given parameter values must also match the corresponding
* parameter sub-patterns. Note that setting this property to true will degrade performance.
* @since 1.1.0
*/
public $matchValue;
/**
* @var string the HTTP verb (e.g. GET, POST, DELETE) that this rule should match.
* If this rule can match multiple verbs, please separate them with commas.
* If this property is not set, the rule can match any verb.
* Note that this property is only used when parsing a request. It is ignored for URL creation.
* @since 1.1.7
*/
public $verb;
/**
* @var boolean whether this rule is only used for request parsing.
* Defaults to false, meaning the rule is used for both URL parsing and creation.
* @since 1.1.7
*/
public $parsingOnly=false;
/**
* @var string the controller/action pair
*/
public $route;
/**
* @var array the mapping from route param name to token name (e.g. _r1=><1>)
* @since 1.0.5
*/
public $references=array();
/**
* @var string the pattern used to match route
* @since 1.0.5
*/
public $routePattern;
/**
* @var string regular expression used to parse a URL
*/
public $pattern;
/**
* @var string template used to construct a URL
*/
public $template;
/**
* @var array list of parameters (name=>regular expression)
*/
public $params=array();
/**
* @var boolean whether the URL allows additional parameters at the end of the path info.
*/
public $append;
/**
* @var boolean whether host info should be considered for this rule
* @since 1.0.11
*/
public $hasHostInfo;
/**
* Constructor.
* @param string $route the route of the URL (controller/action)
* @param string $pattern the pattern for matching the URL
*/
public function __construct($route,$pattern)
{
if(is_array($route))
{
foreach(array(‘urlSuffix’, ‘caseSensitive’, ‘defaultParams’, ‘matchValue’, ‘verb’, ‘parsingOnly’) as $name)
{
if(isset($route[$name]))
$this->$name=$route[$name];
}
if(isset($route['pattern']))
$pattern=$route['pattern'];
$route=$route[0];
}
$this->route=trim($route,‘/’);
$tr2['/']=$tr['/']=‘\\/’;
if(strpos($route,‘<’)!==false && preg_match_all(‘/<(\w+)>/’,$route,$matches2))
{
foreach($matches2[1] as $name)
$this->references[$name]=“<$name>”;
}
$this->hasHostInfo=!strncasecmp($pattern,‘http://’,7) || !strncasecmp($pattern,‘https://’,8);
if($this->verb!==null)
$this->verb=preg_split(‘/[\s,]+/’,strtoupper($this->verb),-1,PREG_SPLIT_NO_EMPTY);
if(preg_match_all(‘/<(\w+):?(.*?)?>/’,$pattern,$matches))
{
$tokens=array_combine($matches[1],$matches[2]);
foreach($tokens as $name=>$value)
{
if($value===”)
$value=‘[^\/]+’;
$tr["<$name>"]=“(?P<$name>$value)”;
if(isset($this->references[$name]))
$tr2["<$name>"]=$tr["<$name>"];
else
$this->params[$name]=$value;
}
}
$p=rtrim($pattern,‘*’);
$this->append=$p!==$pattern;
$p=trim($p,‘/’);
$this->template=preg_replace(‘/<(\w+):?.*?>/’,‘<$1>’,$p);
$this->pattern=‘/^’.strtr($this->template,$tr).‘\/’;
if($this->append)
$this->pattern.=‘/u’;
else
$this->pattern.=‘$/u’;
if
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:475619次
    • 积分:4524
    • 等级:
    • 排名:第6950名
    • 原创:17篇
    • 转载:151篇
    • 译文:7篇
    • 评论:34条
    文章分类
    最新评论