Django url 路由匹配过程详解

1 django 如何处理一个请求

当一个用户请求django 站点的一个页面，下面是django 系统决定执行哪个python 代码使用的算法：

django 确定使用根 urlconf 模块。通常，这是 root_urlconf 设置的值（即 settings 中的 root_urlconf），但如果传入 httprequest 对象拥有 urlconf 属性（通过中间件设置），它的值将被用来代替 root_urlconf 设置。可以在 django/core/handlers/base.py 发现该逻辑。

class basehandler:
  ...
  def _get_response(self, request):
    ...
    if hasattr(request, 'urlconf'):
      urlconf = request.urlconf
      set_urlconf(urlconf)
      resolver = get_resolver(urlconf)
    else:
      resolver = get_resolver()

django 加载该 python 模块并寻找可用的 urlpatterns 。它是 django.urls.path() 和(或) django.urls.re_path() 实例的序列(sequence)。其实就是我们写的 url.py

django 会按顺序遍历每个 url 模式，然后会在所请求的url匹配到第一个模式后停止，并与 path_info 匹配。这个是路由匹配的关键，相关逻辑均在django/urls/resolvers.py。其中有几个比较重要的概念，如regexpattern、routepattern、urlpattern、urlresolver。其中urlresolver有嵌套的逻辑，下文详述。

一旦有 url 匹配成功，django 导入并调用相关的视图，这个视图是一个python 函数（或基于类的视图 class-based view ）。匹配成功会返回一个resolvermatch对象。

如果没有 url 被匹配，或者匹配过程中出现了异常，django 会调用一个适当的错误处理视图。

本文详述 2、3，即 urlpatterns 相关概念和路由匹配的过程。

2 url 配置文件

在 django 2 之后通常会使用 path/re_path 来设置路由，还要一个比较特殊的方法 include 。

• path: 用于普通路径
• re_path：用于正则路径
• include： 将一个子 url 配置文件导入

如下示例:

urlpatterns = [
  path('index/', views.index), # 普通路径
  re_path(r'^articles/([0-9]{4})/$', views.articles), # 正则路径
  path("app01/", include("app01.urls")),
]

上面的配置文件，设置了3条 urlpattern，分别是普通路径 index/ 与 视图函数 views.index，正则路径 ^articles/([0-9]{4})/$ 与视图函数 views.articles 绑定。app01/ 和app01.urls 绑定，app01.urls 不是一个视图函数，而是一个子模块的 urlpatterns。
可以看到 urlpattern 可以把一个 url 和视图函数绑定，也可以和一个子 urlpattern 进行绑定。

2.1 path、re_path

设置路由的几个函数均定义在 django/urls/conf.py 中。

def include(arg, namespace=none):
  ...
  return (urlconf_module, app_name, namespace)


def _path(route, view, kwargs=none, name=none, pattern=none):
  if isinstance(view, (list, tuple)):
    # for include(...) processing.
    pattern = pattern(route, is_endpoint=false)
    urlconf_module, app_name, namespace = view
    return urlresolver(
      pattern,
      urlconf_module,
      kwargs,
      app_name=app_name,
      namespace=namespace,
    )
  elif callable(view):
    pattern = pattern(route, name=name, is_endpoint=true)
    return urlpattern(pattern, view, kwargs, name)
  else:
    raise typeerror('view must be a callable or a list/tuple in the case of include().')


path = partial(_path, pattern=routepattern)
re_path = partial(_path, pattern=regexpattern)

首先先来看下 path 和 re_path，这两个函数分别被 functools 下面的 partial 封装了一下。partial 的作用简单来说就是将一个函数的某些参数给固定住，返回一个新的函数。详细文档可以查看partial 文档。
这样就不难理解 path 和 re_path，他们就是就是绑定了不同的 pattern 参数的 _path 函数。进一步查看 _path 内部的逻辑，

第一个分支 如果绑定的是一个 list或者tuple，使用 urlresolver 去解析，其实此时就是使用了 include 来定义 urlpattern。
另外一种情况如果绑定的 view 是可以调用的，那就使用 urlpattern 去解析。urlpattern 中的 pattern 参数就是根据是采用 path/re_path 方法分别对应 routepattern/regexpattern。

2.2 include

def include(arg, namespace=none):
  ...
  if isinstance(urlconf_module, str):
    urlconf_module = import_module(urlconf_module)
  patterns = getattr(urlconf_module, 'urlpatterns', urlconf_module)
  app_name = getattr(urlconf_module, 'app_name', app_name)
  ...
  return (urlconf_module, app_name, namespace)

include 方法所做的工作就是通过 import_module 将定义的 url 模块导入。返回一个由子 urlconf 模块、app_name、命名空间 namespace 组成的元组。回到刚刚上面的 _path 中第一个分支。将这个元组里面参数代入 urlresolver 并返回。

3 urlpattern 与 urlresolver

3.1 urlpattern

上面提到如果url定义中绑定是一个可以直接调用的view。那就是使用urlpattern直接去解析。

class urlpattern:
  def __init__(self, pattern, callback, default_args=none, name=none):
    # 需要匹配的 urlpattern，这里根据是path还是re_path 分别是 routepattern或regexpattern的实例
    self.pattern = pattern
    self.callback = callback # the view
    self.default_args = default_args or {}
    self.name = name
  ...
  def resolve(self, path):
    调用 routepattern 或 regexpattern 的实例中的 match 方法进行匹配（注意这里不是 re 模块里面的 match）
    match = self.pattern.match(path)
    if match:
      new_path, args, kwargs = match
      # pass any extra_kwargs as **kwargs.
      kwargs.update(self.default_args)
      # 匹配成功返回 `resolvermatch`
      return resolvermatch(self.callback, args, kwargs, self.pattern.name, route=str(self.pattern))
  ...

urlpattern 初始化时其中的 pattern 就是根据是使用 path/re_path 分别对应routepattern或regexpattern。其实就是指定匹配的模式是普通路由还是正则的路由。

3.2 urlresolver

urlresolver 源码中比较核心的是 resolve 函数，就是传入一个 path，进行匹配。

class urlresolver:
  def resolve(self, path):
    path = str(path) # path may be a reverse_lazy object
    tried = []
    # 匹配 path
    match = self.pattern.match(path)
    if match:
      new_path, args, kwargs = match
      # 如果匹配成功，则继续匹配它的url_patterns
      for pattern in self.url_patterns:
        try:
          # 这个pattern可能是urlpattern，也可能是urlresolver；如果是urlpattern，匹配成功则返回resolvermatch；如果是urlresolver，则会递归调用下去。
          sub_match = pattern.resolve(new_path)
        ...
        else:
          if sub_match:
            ...
            # 匹配成功返回resolvermatch
            return resolvermatch(
              sub_match.func,
              sub_match_args,
              sub_match_dict,
              sub_match.url_name,
              [self.app_name] + sub_match.app_names,
              [self.namespace] + sub_match.namespaces,
              self._join_route(current_route, sub_match.route),
            )
          tried.append([pattern])
      raise resolver404({'tried': tried, 'path': new_path})
    raise resolver404({'path': path})

urlresolver 比较关键的逻辑在 循环匹配 pattern 过程，如果 pattern是urlpattern匹配成功直接返回resolvermatch，如果是另一个urlresolver，则实现了递归调用。

django 就是通过这个 urlresolver 实现了多级 url 配置。

4 总结

django 路由匹配的有几个比较核心的概念 path/re_path/include、regexpattern/routepattern、urlpattern/urlresolver。
首先用 partial 封装 _path，绑定了一个 pattern 匹配模式（regexpattern/routepattern），后面多次用到了这个 pattern。然后就是根据 view 是元组还是可调用视图函数，分别使用urlresolver和urlpattern去解析，这两个类解析之后都会返回给resolvermatch，由它去回调匹配成功后的结果（view和args等）。

本文从全局的角度大致说明了django路由的匹配流程，后续将从细节部分说明其中的一些关键点。

到此这篇关于django url 路由匹配过程详解的文章就介绍到这了,更多相关django url 路由匹配内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！