Analyse des exemples de configuration d'emplacement dans le serveur Nginx-Nginx-php.cn

1, la chaîne correspond avec précision à une chaîne avec "=". " Si l'emplacement est préfixé par "^~", il s'arrêtera et utilisera la configuration de cet emplacement ;

2. La chaîne correspond aux emplacements non réguliers et non spéciaux restants. Si elle correspond à un emplacement avec le "^ ~" préfixe, ça s'arrêtera ;

3, correspondance régulière, l'ordre de correspondance est l'ordre dans lequel les emplacements apparaissent dans le fichier de configuration. Si un emplacement normal correspond, arrêtez et utilisez la configuration de cet emplacement ; sinon, utilisez la configuration d'emplacement avec la plus grande correspondance de chaîne obtenue à l'étape 2. # Lorsque nous atteignons le deuxième emplacement, nous effectuons une correspondance régulière. Évidemment, il n'y a pas de correspondance, nous utilisons donc la configuration du deuxième emplacement : configurationb

3, /images /1.jpg -> de la chaîne correspond au deuxième emplacement, mais le troisième emplacement correspond également au préfixe, et à ce moment, c'est la correspondance de chaîne maximale pour cette URL dans le fichier de configuration, et l'emplacement a le préfixe "^~", puis le régulier la correspondance n'est plus effectuée et la configuration est finalement utilisée c

4,/some/other/path/to/1.jpg -> Tout d'abord, la même chaîne dans la partie préfixe correspond au deuxième emplacement, puis la correspondance régulière est effectuée. Si la correspondance régulière est réussie, la configuration d

est utilisée nginx. Les règles de correspondance d'URL sont en fait un peu inappropriées. Dans la plupart des cas, une URL doit d'abord faire l'objet d'une correspondance régulière, puis d'une correspondance régulière. est effectué en premier et il n'y a pas de correspondance, puis la correspondance des chaînes est effectuée. Dans de nombreux cas, cela peut permettre de gagner du temps lors de la correspondance des chaînes. Quoi qu'il en soit, jetons un coup d'œil à l'implémentation dans le code source de nginx. Avant d'introduire le processus de localisation de correspondance, introduisons d'abord l'organisation de l'emplacement dans nginx. En fait, lors de la phase d'analyse de la configuration, nginx fera correspondre l'emplacement de la chaîne avec. l'emplacement de la correspondance régulière. L'emplacement est stocké dans les deux champs suivants de la structure ngx_http_core_loc_conf_t de la configuration loc du module http core :

location = / { 
 # matches the query / only. 
 [ configuration a ]  
} 
location / { 
 # matches any query, since all queries begin with /, but regular 
 # expressions and any longer conventional blocks will be 
 # matched first. 
 [ configuration b ]  
} 
location ^~ /images/ { 
 # matches any query beginning with /images/ and halts searching, 
 # so regular expressions will not be checked. 
 [ configuration c ]  
} 
location ~* \.(gif|jpg|jpeg)$ { 
 # matches any request ending in gif, jpg, or jpeg. however, all 
 # requests to the /images/ directory will be handled by 
 # configuration c.   
 [ configuration d ]  
} 
 
location @named { 
 # such locations are not used during normal processing of requests,  
 # they are intended only to process internally redirected requests (for example error_page, try_files). 
 [ configuration e ]  
}

Copier après la connexion

D'après les types de ces deux champs, on peut voir que les emplacements correspondent par les chaînes sont organisées dans une arborescence d'emplacements, et les emplacements correspondent à des expressions régulières. C'est juste un tableau,

ngx_http_location_tree_node_t  *static_locations; 
(ngx_pcre) 
ngx_http_core_loc_conf_t    **regex_locations; 
if

Copier après la connexion

Après avoir lu la configuration, tous les serveurs sont enregistrés dans le tableau des serveurs dans la configuration principale du module principal http, et les emplacements dans chaque serveur est enregistré en http dans l'ordre dans lequel il apparaît dans la configuration. Dans la file d'attente Locations de la configuration LOC du module Core, le code de chaque serveur est d'abord trié et classé. Cette étape se produit dans la fonction ngx_http_init_location() :

Rreeee
.

Les étapes ci-dessus correspondront à l'emplacement habituel. Après l'enregistrement, l'arborescence des emplacements est établie dans ngx_http_init_static_location_trees :

location tree和regex_locations数组建立过程在ngx_http_block中：
/* create location trees */ 
 
  for (s = 0; s < cmcf->servers.nelts; s++) { 
 
    clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index]; 
 
    if (ngx_http_init_locations(cf, cscfp[s], clcf) != ngx_ok) { 
      return ngx_conf_error; 
    } 
 
    if (ngx_http_init_static_location_trees(cf, clcf) != ngx_ok) { 
      return ngx_conf_error; 
    } 
  }

Copier après la connexion

Après avoir été traitée par la fonction ngx_http_init_location(), la file d'attente des emplacements est déjà en ordre. Le travail principal en cours d'établissement. l'arbre ternaire est dans ngx_http_create_locations_list() et ngx_http_create_locations_tree Complété dans (), ces deux fonctions sont toutes deux des fonctions récursives. La première fonction récursif chaque nœud de la file d'attente des emplacements, obtient l'emplacement préfixé par le nom du nœud actuel et l'enregistre sous. le champ de liste du nœud actuel, par exemple, pour les emplacements suivants :

static ngx_int_t 
ngx_http_init_locations(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf, 
  ngx_http_core_loc_conf_t *pclcf) 
{ 
 ... 
  locations = pclcf->locations; 
 
 ... 
  /* 按照类型排序location，排序完后的队列： (exact_match 或 inclusive) (排序好的，如果某个exact_match名字和inclusive location相同，exact_match排在前面) 
    | regex（未排序）| named(排序好的) | noname（未排序）*/ 
  ngx_queue_sort(locations, ngx_http_cmp_locations); 
 
  named = null; 
  n = 0; 
#if (ngx_pcre) 
  regex = null; 
  r = 0; 
#endif 
 
  for (q = ngx_queue_head(locations); 
     q != ngx_queue_sentinel(locations); 
     q = ngx_queue_next(q)) 
  { 
    lq = (ngx_http_location_queue_t *) q; 
 
    clcf = lq->exact ? lq->exact : lq->inclusive; 
    /* 由于可能存在nested location，也就是location里面嵌套的location，这里需要递归的处理一下当前location下面的nested location */ 
    if (ngx_http_init_locations(cf, null, clcf) != ngx_ok) { 
      return ngx_error; 
    } 
 
#if (ngx_pcre) 
 
    if (clcf->regex) { 
      r++; 
 
      if (regex == null) { 
        regex = q; 
      } 
 
      continue; 
    } 
 
#endif 
 
    if (clcf->named) { 
      n++; 
 
      if (named == null) { 
        named = q; 
      } 
 
      continue; 
    } 
 
    if (clcf->noname) { 
      break; 
    } 
  } 
 
  if (q != ngx_queue_sentinel(locations)) { 
    ngx_queue_split(locations, q, &tail); 
  } 
  /* 如果有named location，将它们保存在所属server的named_locations数组中 */ 
  if (named) { 
    clcfp = ngx_palloc(cf->pool, 
              (n + 1) * sizeof(ngx_http_core_loc_conf_t **)); 
    if (clcfp == null) { 
      return ngx_error; 
    } 
 
    cscf->named_locations = clcfp; 
 
    for (q = named; 
       q != ngx_queue_sentinel(locations); 
       q = ngx_queue_next(q)) 
    { 
      lq = (ngx_http_location_queue_t *) q; 
 
      *(clcfp++) = lq->exact; 
    } 
 
    *clcfp = null; 
 
    ngx_queue_split(locations, named, &tail); 
  } 
 
#if (ngx_pcre) 
  /* 如果有正则匹配location，将它们保存在所属server的http core模块的loc配置的regex_locations 数组中， 
    这里和named location保存位置不同的原因是由于named location只能存在server里面，而regex location可以作为nested location */ 
  if (regex) { 
 
    clcfp = ngx_palloc(cf->pool, 
              (r + 1) * sizeof(ngx_http_core_loc_conf_t **)); 
    if (clcfp == null) { 
      return ngx_error; 
    } 
 
    pclcf->regex_locations = clcfp; 
 
    for (q = regex; 
       q != ngx_queue_sentinel(locations); 
       q = ngx_queue_next(q)) 
    { 
      lq = (ngx_http_location_queue_t *) q; 
 
      *(clcfp++) = lq->exact; 
    } 
 
    *clcfp = null; 
 
    ngx_queue_split(locations, regex, &tail); 
  } 
 
#endif 
 
  return ngx_ok; 
}

Copier après la connexion

Le résultat trié est /abc /efg /efgaa =/xyz /xyz /xyza /xyzab /xyzb, et le résultat après déduplication est /abc /efg /efgaa /xyz /xyza /xyzab/xyzb, Le résultat après exécution de ngx_http_create_locations_list() est :

Enfin, jetons un œil à la fonction ngx_http_create_locations_tree :

static ngx_http_location_tree_node_t * 
ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations, 
  size_t prefix) 
{ 
  ... 
  /* 根节点为locations队列的中间节点 */ 
  q = ngx_queue_middle(locations); 
 
  lq = (ngx_http_location_queue_t *) q; 
  len = lq->name->len - prefix; 
   
  node = ngx_palloc(cf->pool, 
           offsetof(ngx_http_location_tree_node_t, name) + len); 
  if (node == null) { 
    return null; 
  } 
 
  node->left = null; 
  node->right = null; 
  node->tree = null; 
  node->exact = lq->exact; 
  node->inclusive = lq->inclusive; 
 
  node->auto_redirect = (u_char) ((lq->exact && lq->exact->auto_redirect) 
              || (lq->inclusive && lq->inclusive->auto_redirect)); 
 
  node->len = (u_char) len; 
  ngx_memcpy(node->name, &lq->name->data[prefix], len); 
 
  /* 从中间节点开始断开 */ 
  ngx_queue_split(locations, q, &tail); 
 
  if (ngx_queue_empty(locations)) { 
    /* 
     * ngx_queue_split() insures that if left part is empty, 
     * then right one is empty too 
     */ 
    goto inclusive; 
  } 
 
  /* 从locations左半部分得到左子树 */ 
  node->left = ngx_http_create_locations_tree(cf, locations, prefix); 
  if (node->left == null) { 
    return null; 
  } 
 
  ngx_queue_remove(q); 
 
  if (ngx_queue_empty(&tail)) { 
    goto inclusive; 
  } 
  
 
  /* 从locations右半部分得到右子树 */ 
  node->right = ngx_http_create_locations_tree(cf, &tail, prefix); 
  if (node->right == null) { 
    return null; 
  } 
 
inclusive: 
 
  if (ngx_queue_empty(&lq->list)) { 
    return node; 
  } 
 
  /* 从list队列得到tree子树 */ 
  node->tree = ngx_http_create_locations_tree(cf, &lq->list, prefix + len); 
  if (node->tree == null) { 
    return null; 
  } 
 
  return node; 
} 
     location tree节点的ngx_http_location_tree_node_s结构：
struct ngx_http_location_tree_node_s { 
  ngx_http_location_tree_node_t  *left; 
  ngx_http_location_tree_node_t  *right; 
  ngx_http_location_tree_node_t  *tree; 
 
  ngx_http_core_loc_conf_t    *exact; 
  ngx_http_core_loc_conf_t    *inclusive; 
 
  u_char              auto_redirect; 
  u_char              len; 
  u_char              name[1]; 
};

Copier après la connexion

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节点的完整名字）：

Analyse des exemples de configuration demplacement dans le serveur Nginx

ps：关于 location modifier
1. =
这会完全匹配指定的 pattern ，且这里的 pattern 被限制成简单的字符串，也就是说这里不能使用正则表达式。

example:
server {
  server_name jb51.net;
  location = /abcd {
  […]
  }
}

Copier après la connexion

匹配情况：

  http://jb51.net/abcd    # 正好完全匹配
  http://jb51.net/abcd    # 如果运行 nginx server 的系统本身对大小写不敏感，比如 windows ，那么也匹配
  http://jb51.net/abcd?param1&para;m2  # 忽略查询串参数（query string arguments），这里就是 /abcd 后面的 ?param1&para;m2
  http://jb51.net/abcd/  # 不匹配，因为末尾存在反斜杠（trailing slash），nginx 不认为这种情况是完全匹配
  http://jb51.net/abcde  # 不匹配，因为不是完全匹配

Copier après la connexion

2. (none)
可以不写 location modifier ，nginx 仍然能去匹配 pattern 。这种情况下，匹配那些以指定的 patern 开头的 uri，注意这里的 uri 只能是普通字符串，不能使用正则表达式。

example:
server {
  server_name jb51.net;
  location /abcd {
  […]
  }
}

Copier après la connexion

匹配情况：

  http://jb51.net/abcd    # 正好完全匹配
  http://jb51.net/abcd    # 如果运行 nginx server 的系统本身对大小写不敏感，比如 windows ，那么也匹配
  http://jb51.net/abcd?param1&para;m2  # 忽略查询串参数（query string arguments），这里就是 /abcd 后面的 ?param1&para;m2
  http://jb51.net/abcd/  # 末尾存在反斜杠（trailing slash）也属于匹配范围内
  http://jb51.net/abcde  # 仍然匹配，因为 uri 是以 pattern 开头的

Copier après la connexion

3. ~
这个 location modifier 对大小写敏感，且 pattern 须是正则表达式

example:
server {
  server_name jb51.net;
  location ~ ^/abcd$ {
  […]
  }
}

Copier après la connexion

匹配情况：

  http://jb51.net/abcd    # 完全匹配
  http://jb51.net/abcd    # 不匹配，~ 对大小写是敏感的
  http://jb51.net/abcd?param1&para;m2  # 忽略查询串参数（query string arguments），这里就是 /abcd 后面的 ?param1&para;m2
  http://jb51.net/abcd/  # 不匹配，因为末尾存在反斜杠（trailing slash），并不匹配正则表达式 ^/abcd$
  http://jb51.net/abcde  # 不匹配正则表达式 ^/abcd$

Copier après la connexion

注意：对于一些对大小写不敏感的系统，比如 windows ，~ 和 ~* 都是不起作用的，这主要是操作系统的原因。

4. ~*
与 ~ 类似，但这个 location modifier 不区分大小写，pattern 须是正则表达式

example:
server {
  server_name jb51.net;
  location ~* ^/abcd$ {
  […]
  }
}

Copier après la connexion

匹配情况：

 http://jb51.net/abcd    # 完全匹配
  http://jb51.net/abcd    # 匹配，这就是它不区分大小写的特性
  http://jb51.net/abcd?param1&para;m2  # 忽略查询串参数（query string arguments），这里就是 /abcd 后面的 ?param1&para;m2
  http://jb51.net/abcd/  # 不匹配，因为末尾存在反斜杠（trailing slash），并不匹配正则表达式 ^/abcd$
  http://jb51.net/abcde  # 不匹配正则表达式 ^/abcd$

Copier après la connexion

5. ^~
匹配情况类似 2. (none) 的情况，以指定匹配模式开头的 uri 被匹配，不同的是，一旦匹配成功，那么 nginx 就停止去寻找其他的 location 块进行匹配了（与 location 匹配顺序有关）

6. @
用于定义一个 location 块，且该块不能被外部 client 所访问，只能被 nginx 内部配置指令所访问，比如 try_files or error_page

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Php8, je viens aussi

Apprenez la mise en page d'un site Web en 30 minutes

Tutoriel vidéo Shangguan Oracle débutant à compétent

Votre première ligne de code UNI-APP

Flutter de zéro au lancement de l'application

Brother Lian Nouveau didacticiel vidéo Linux

Tutoriel vidéo AXURE 9 (convient à l'interface utilisateur interactive de conception de produits du chef de produit)

Tutoriel vidéo PS Zero Basic Proficiency

Tutoriel vidéo de 16 jours sur l'interface utilisateur pour vous aider à démarrer

Tutoriel vidéo sur les techniques PS et les techniques de découpage

Tutoriel vidéo sur la construction et le lancement de projets d'Alibaba Cloud Environment

Présentation des réseaux informatiques - Connaissances de base que les programmeurs doivent maîtriser

Tutoriel essentiel pour les programmeurs - Explication du protocole HTTP

Tutoriel vidéo Websocket

Analyse des exemples de configuration d'emplacement dans le serveur Nginx