关于nginx代码解析，我师兄雕梁的博客（http://simohayha.javaeye.com）有一系列的文章可以阅读。我这里将只介绍他博客里没有关注到的或者讲述不详细的，但是我个人又认为是nginx里面比较重要的东西。在这一篇文章里，我将介绍nginx关于location的处理，大家都知道Nginx配置文件里面会有很多的location，nginx的配置指令的作用域可以分为 main，server，location这3个种，实际上这3者不是依次包含的关系，而是相互独立的关系，比如一个只具有main级别作用域的指令，是不能写在某个server或者location内的，模块的某个指令可以同时具有main，server，location这3种作用域，另外每个模块有 main,srv,loc这3个级别的配置，一个模块的main级别的配置对所有的server和location都是共享的，srv级别的配置对所有 location都是共享的，location只有自己独立的loc级别的配置，这就是为什么一个模块的srv和loc级别的配置需要merge，而 main级别的配置不需要merge的原因。这里看起来有点绕，区分一下main，server，location分别作为一种作用域级别和一个主体，类似于形容词和名字的区别，nginx的配置关系还是不难理解的。

一般来说一个请求url过来，nginx会将它解析到某一个location来处理。这个解析的过程实际上根据location的配置基本可以分为字符串匹配和正则表达式匹配这2种。对于location的组织方式，最简单的就是直接将它们保存为一个链表，解析url的时候一个一个遍历即可找到相应location，但是这样效率太低，对像nginx这种高性能的服务器来说是完全不可取的，nginx将字符串匹配的location组织成了一个三叉的字符串排序树，而且建立的时候也考虑了树的平衡性。文章后面我讲详细介绍源码的实现。

首先我来大概的介绍一下location的种类和匹配规则，以nginx wiki(http://wiki.nginx.org/HttpCoreModule#location)的例子做说明：

  1. location  = / {
  2. # matches the query / only.
  3. [ configuration A ]
  4. }
  5. location  / {
  6. # matches any query, since all queries begin with /, but regular
  7. # expressions and any longer conventional blocks will be
  8. # matched first.
  9. [ configuration B ]
  10. }
  11. location ^~ /images/ {
  12. # matches any query beginning with /images/ and halts searching,
  13. # so regular expressions will not be checked.
  14. [ configuration C ]
  15. }
  16. location ~* \.(gif|jpg|jpeg)$ {
  17. # matches any request ending in gif, jpg, or jpeg. However, all
  18. # requests to the /images/ directory will be handled by
  19. # Configuration C.
  20. [ configuration D ]
  21. }
  22. location  @named {
  23. # Such locations are not used during normal processing of requests,
  24. # they are intended only to process internally redirected requests (for example error_page, try_files).
  25. [ configuration E ]
  26. }

可以看到上面的例子中有5种不同类型的location，其中第4个带 “~” 号前缀的为需要正则匹配的location，nginx在进行url解析时对这5种不同类型的location具有不同的优先级规则，大致的规则如下：

1，字符串精确匹配到一个带 “=” 号前缀的location，则停止，且使用这个location的配置；

2，字符串匹配剩下的非正则和非特殊location，如果匹配到某个带 "^~" 前缀的location，则停止；

3，正则匹配，匹配顺序为location在配置文件中出现的顺序。如果匹配到某个正则location，则停止，并使用这个location的配置；否则，使用步骤2中得到的具有最大字符串匹配的location配置。

例如，对下面的请求有:

1， /   ->   精确匹配到第1个location，匹配停止，使用configuration A
2，/some/other/url    ->  首先前缀部分字符串匹配到了第2个location，然后进行正则匹配，显然没有匹配上，则使用第2个location的配置configurationB
3，/images /1.jpg  ->  首先前缀部分字符串匹配到了第2个location，但是接着对第3个location也前缀匹配上了，而且这时已经是配置文件里面对这个url的最大字符串匹配了，并且location带有 "^~" 前缀，则不再进行正则匹配，最终使用configuration C
4，/some/other/path/to/1.jpg  -> 首先前缀部分同样字符串匹配到了第2个location，然后进行正则匹配，这时正则匹配成功，则使用congifuration D

nginx的url匹配规则实际上有点不妥，大部分情况下一个url必须先进行字符串匹配，然后再做正则匹配，但是实际上如果先做正则匹配，没有匹配上再 做字符串匹配，在很多情况下可以节省掉做字符串匹配的时间。不管怎样，先来看一下nginx源码里面的实现，在介绍匹配location过程之前，先来介 绍一下nginx里面对location的组织方式，实际上在配置解析阶段，nginx将字符串匹配的location和正则匹配的location分别 存储在http core模块的loc配置ngx_http_core_loc_conf_t结构的下面2个字段：

  1. ngx_http_location_tree_node_t   *static_locations;
  2. (NGX_PCRE)
  3. ngx_http_core_loc_conf_t       **regex_locations;
  4. if

从这2个字段的类型可以看出，字符串匹配的location被组织成了一个location tree，而正则匹配的location只是一个数组，location tree和regex_locations数组建立过程在ngx_http_block中：

  1. /* create location trees */
  2. for (s = 0; s < cmcf->servers.nelts; s++) {
  3. clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
  4. if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
  5. return NGX_CONF_ERROR;
  6. }
  7. if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
  8. return NGX_CONF_ERROR;
  9. }
  10. }

经过配置的读取之后，所有server都被保存在http core模块的main配置中的servers数组中，而每个server里面的location都被按配置中出现的顺序保存在http core模块的loc配置的locations队列中，上面的代码中先对每个server的location进行排序和分类处理，这一步发生在 ngx_http_init_location()函数中：

  1. static ngx_int_t
  2. ngx_http_init_locations(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  3. ngx_http_core_loc_conf_t *pclcf)
  4. {
  5. ...
  6. locations = pclcf->locations;
  7. ...
  8. /* 按照类型排序location，排序完后的队列：  (exact_match 或 inclusive) (排序好的，如果某个exact_match名字和inclusive location相同，exact_match排在前面)
  9. |  regex（未排序）| named(排序好的)  |  noname（未排序）*/
  10. ngx_queue_sort(locations, ngx_http_cmp_locations);
  11. named = NULL;
  12. n = 0;
  13. #if (NGX_PCRE)
  14. regex = NULL;
  15. r = 0;
  16. #endif
  17. for (q = ngx_queue_head(locations);
  18. q != ngx_queue_sentinel(locations);
  19. q = ngx_queue_next(q))
  20. {
  21. lq = (ngx_http_location_queue_t *) q;
  22. clcf = lq->exact ? lq->exact : lq->inclusive;
  23. /* 由于可能存在nested location，也就是location里面嵌套的location，这里需要递归的处理一下当前location下面的nested location */
  24. if (ngx_http_init_locations(cf, NULL, clcf) != NGX_OK) {
  25. return NGX_ERROR;
  26. }
  27. #if (NGX_PCRE)
  28. if (clcf->regex) {
  29. r++;
  30. if (regex == NULL) {
  31. regex = q;
  32. }
  33. continue;
  34. }
  35. #endif
  36. if (clcf->named) {
  37. n++;
  38. if (named == NULL) {
  39. named = q;
  40. }
  41. continue;
  42. }
  43. if (clcf->noname) {
  44. break;
  45. }
  46. }
  47. if (q != ngx_queue_sentinel(locations)) {
  48. ngx_queue_split(locations, q, &tail);
  49. }
  50. /* 如果有named location，将它们保存在所属server的named_locations数组中 */
  51. if (named) {
  52. clcfp = ngx_palloc(cf->pool,
  53. (n + 1) * sizeof(ngx_http_core_loc_conf_t **));
  54. if (clcfp == NULL) {
  55. return NGX_ERROR;
  56. }
  57. cscf->named_locations = clcfp;
  58. for (q = named;
  59. q != ngx_queue_sentinel(locations);
  60. q = ngx_queue_next(q))
  61. {
  62. lq = (ngx_http_location_queue_t *) q;
  63. *(clcfp++) = lq->exact;
  64. }
  65. *clcfp = NULL;
  66. ngx_queue_split(locations, named, &tail);
  67. }
  68. #if (NGX_PCRE)
  69. /* 如果有正则匹配location，将它们保存在所属server的http core模块的loc配置的regex_locations 数组中，
  70. 这里和named location保存位置不同的原因是由于named location只能存在server里面，而regex location可以作为nested location */
  71. if (regex) {
  72. clcfp = ngx_palloc(cf->pool,
  73. (r + 1) * sizeof(ngx_http_core_loc_conf_t **));
  74. if (clcfp == NULL) {
  75. return NGX_ERROR;
  76. }
  77. pclcf->regex_locations = clcfp;
  78. for (q = regex;
  79. q != ngx_queue_sentinel(locations);
  80. q = ngx_queue_next(q))
  81. {
  82. lq = (ngx_http_location_queue_t *) q;
  83. *(clcfp++) = lq->exact;
  84. }
  85. *clcfp = NULL;
  86. ngx_queue_split(locations, regex, &tail);
  87. }
  88. #endif
  89. return NGX_OK;
  90. }

上面的步骤将正则匹配的location保存好了，location tree的建立在ngx_http_init_static_location_trees中进行：

  1. static ngx_int_t
  2. ngx_http_init_static_location_trees(ngx_conf_t *cf,
  3. ngx_http_core_loc_conf_t *pclcf)
  4. {
  5. ngx_queue_t                *q, *locations;
  6. ngx_http_core_loc_conf_t   *clcf;
  7. ngx_http_location_queue_t  *lq;
  8. locations = pclcf->locations;
  9. if (locations == NULL) {
  10. return NGX_OK;
  11. }
  12. if (ngx_queue_empty(locations)) {
  13. return NGX_OK;
  14. }
  15. /* 这里也是由于nested location，需要递归一下 */
  16. for (q = ngx_queue_head(locations);
  17. q != ngx_queue_sentinel(locations);
  18. q = ngx_queue_next(q))
  19. {
  20. lq = (ngx_http_location_queue_t *) q;
  21. clcf = lq->exact ? lq->exact : lq->inclusive;
  22. if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
  23. return NGX_ERROR;
  24. }
  25. }
  26. /* join队列中名字相同的inclusive和exact类型location，也就是如果某个exact_match的location名字和普通字符串匹配的location名字相同的话，
  27. 就将它们合到一个节点中，分别保存在节点的exact和inclusive下，这一步的目的实际是去重，为后面的建立排序树做准备 */
  28. if (ngx_http_join_exact_locations(cf, locations) != NGX_OK) {
  29. return NGX_ERROR;
  30. }
  31. /* 递归每个location节点，得到当前节点的名字为其前缀的location的列表，保存在当前节点的list字段下 */
  32. ngx_http_create_locations_list(locations, ngx_queue_head(locations));
  33. /* 递归建立location三叉排序树 */
  34. pclcf->static_locations = ngx_http_create_locations_tree(cf, locations, 0);
  35. if (pclcf->static_locations == NULL) {
  36. return NGX_ERROR;
  37. }
  38. return NGX_OK;
  39. }

经过ngx_http_init_location（）函数处理之后，locations队列已经是排好序的了，建立三叉树的过程的主要工作都在ngx_http_create_locations_list()和ngx_http_create_locations_tree()中完成，这2个 函数都是递归函数，第1个函数递归locations队列中的每个节点，得到以当前节点的名字为前缀的location，并保存在当前节点的list字段 下，例如，对下列location：

  1. location  /xyz {
  2. }
  3. location  = /xyz {
  4. }
  5. location  /xyza {
  6. }
  7. location  /xyzab {
  8. }
  9. location  /xyzb {
  10. }
  11. location  /abc {
  12. }
  13. location  /efg {
  14. }
  15. location  /efgaa {
  16. }

排序的结果为/abc  /efg   /efgaa  =/xyz  /xyz  /xyza /xyzab /xyzb，去重后结果为 /abc  /efg   /efgaa   /xyz  /xyza /xyzab/xyzb，ngx_http_create_locations_list()执行后的结果为：

最后，来看下ngx_http_create_locations_tree函数：

  1. static ngx_http_location_tree_node_t *
  2. ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
  3. size_t prefix)
  4. {
  5. ...
  6. /* 根节点为locations队列的中间节点 */
  7. q = ngx_queue_middle(locations);
  8. lq = (ngx_http_location_queue_t *) q;
  9. len = lq->name->len - prefix;
  10. node = ngx_palloc(cf->pool,
  11. offsetof(ngx_http_location_tree_node_t, name) + len);
  12. if (node == NULL) {
  13. return NULL;
  14. }
  15. node->left = NULL;
  16. node->right = NULL;
  17. node->tree = NULL;
  18. node->exact = lq->exact;
  19. node->inclusive = lq->inclusive;
  20. node->auto_redirect = (u_char) ((lq->exact && lq->exact->auto_redirect)
  21. || (lq->inclusive && lq->inclusive->auto_redirect));
  22. node->len = (u_char) len;
  23. ngx_memcpy(node->name, &lq->name->data[prefix], len);
  24. /* 从中间节点开始断开 */
  25. ngx_queue_split(locations, q, &tail);
  26. if (ngx_queue_empty(locations)) {
  27. /*
  28. * ngx_queue_split() insures that if left part is empty,
  29. * then right one is empty too
  30. */
  31. goto inclusive;
  32. }
  33. /* 从locations左半部分得到左子树 */
  34. node->left = ngx_http_create_locations_tree(cf, locations, prefix);
  35. if (node->left == NULL) {
  36. return NULL;
  37. }
  38. ngx_queue_remove(q);
  39. if (ngx_queue_empty(&tail)) {
  40. goto inclusive;
  41. }
  42. /* 从locations右半部分得到右子树 */
  43. node->right = ngx_http_create_locations_tree(cf, &tail, prefix);
  44. if (node->right == NULL) {
  45. return NULL;
  46. }
  47. inclusive:
  48. if (ngx_queue_empty(&lq->list)) {
  49. return node;
  50. }
  51. /* 从list队列得到tree子树 */
  52. node->tree = ngx_http_create_locations_tree(cf, &lq->list, prefix + len);
  53. if (node->tree == NULL) {
  54. return NULL;
  55. }
  56. return node;
  57. }

location tree节点的ngx_http_location_tree_node_s结构：

  1. struct ngx_http_location_tree_node_s {
  2. ngx_http_location_tree_node_t   *left;
  3. ngx_http_location_tree_node_t   *right;
  4. ngx_http_location_tree_node_t   *tree;
  5. ngx_http_core_loc_conf_t        *exact;
  6. ngx_http_core_loc_conf_t        *inclusive;
  7. u_char                           auto_redirect;
  8. u_char                           len;
  9. u_char                           name[1];
  10. };

location tree结构用到的是left，right，tree 这3个字段， location tree实际上是一个三叉的字符串排序树，而且这里如果某个节点只考虑左，右子树，它是一颗平衡树，它的建立过程有点类似于一颗平衡排序二叉树的建立过程，先排序再用二分查找找到的节点顺序插入，ngx_http_location_tree_node_s的tree节点也是一颗平衡排序树，它是用该节点由ngx_http_create_locations_list()得到的list建立的，也就是该节点的名字是它的tree子树里面的所有节点名字的前缀，所以tree子树里面的所有节点的名字不用保存公共前缀，而且查找的时候，如果是转向tree节点的话，也是不需要再比较父节点的那段字符串了。
         ngx_http_create_locations_tree()函数写的很清晰，它有一个参数是队列locations，它返回一颗三叉树，根节点为locations的中间节点，其左子树为locations队列的左半部分建立的location tree，右子树为location队列的右半部分建立的tree，tree节点为该根节点的list队列建立的tree。

最终建立的location tree如下（为了方便阅读，图中列出了tree节点的完整名字）：

location的匹配发生在nginx请求处理的NGX_HTTP_FIND_CONFIG_PHASE阶段(请求的处理所有PHASE可以看这篇博客http://simohayha.iteye.com/blog/670326)，匹配的规则文章前面已经做过介绍，源码的实现也很简单，这里不再做介绍了。

from：http://blog.csdn.net/fengmo_q/article/details/6683377

最新文章

  1. 模仿东京首页banner轮播，京东新闻上下滚动动画实现（动画实现）
  2. Windows 10 装机回忆录
  3. _.属性和self.属性，我遇到的那些坑
  4. Eclipse魔法堂：修改主题
  5. selenium如何解决IE自动填充表单问题
  6. Go语言的优点(oschina讨论)
  7. BP神经网络分类器的设计
  8. 使用reinterpret_cast的危险
  9. Android应用中使用百度地图API定位自己的位置（二）
  10. Sqlite出现SQL error: database disk image is malformed的处理
  11. Mac下ssh连接远程服务器时自动断开问题
  12. 关于spark中DatatFrame函数操作中isin方法的使用
  13. 第一册：lesson thirty seven。
  14. vue给元素动态添加class
  15. PHP学习笔记(二)
  16. 题解 P5239 【回忆京都】
  17. 20145305 《网络对抗》MSF基础应用
  18. OS X 配置 Apache
  19. 【Docker】基于docker＋etcd＋confd ＋ haproxy构建高可用、自发现的web服务
  20. ORM一对多查询

热门文章

  1. FATE（费用背包，没懂）
  2. information_schema.columns 学习
  3. BufferedStream类 - 缓冲流
  4. JVM命令行选项及GC日志
  5. BFS visit tree
  6. OpenWrt 学习网址
  7. LINUX下 Udev详解
  8. android笔试题集2
  9. February 29(模拟)
  10. Memcached安装，操作，用C#操作