Django源码解析(五) URL配置

一 什么是URL配置

URL配置(URLconf )就像是 Django 所支撑网站的目录。它的本质是 URL 模式以及要为该 URL 模式调用的视图函数之间的映射表。 你就是以这种方式告诉 Django，对于这个 URL 调用这段代码，对于那个 URL 调用那段代码。 例如，当用户访问/foo/时，调用视图函数foo_view()，这个视图函数存在于Python模块文件view.py中。

执行 django-admin.py startproject 时，该脚本会自动为你建了一份 URLconf（即urls.py 文件）。在同时自动创建的settings.py文件中，创建一个变量ROOT_URLCONF，其变量的值就是根URLconf的模块名。默认值是urls.py文件的模块名。

例如：我的Django项目的根目录名为“pearl”，ROOT_URLCONF的默认值为“pearl.urls”。

二 Django如何处理URL配置

要弄清Django如何处理URL配置,先要了解几个概念.

2.1 URL模式

URL模式是指在Django urls模块中,名为urlpatterns的元组中包含的每一个值.通常由patterns方法生成urlpatterns元组的内容.

每个URL模式都需要指定如下几个内容:

1. 一个正则表达式字符串.
2. 一个可调用对象,通常为一个视图函数或一个指定视图函数路径的字符串.
3. 可选的要传递给视图函数的默认参数(字典形式).
4. 一个可选的name参数.
5. 路径前缀,加在视图函数路径字符串的前面组成完整的视图函数路径.可以通过patterns方法的第一个参数指定.

看到这里,了解Django的亲们可能会问,”不是还有一种第二参数使用include方法的URL模式么?哥们你没hold住哇?”O(∩_∩)O~这个稍后再侃.

类django.core.urlresolvers.RegexURLPattern用来表示Django URL模式.

class RegexURLPattern(object):    def __init__(self, regex, callback, default_args=None, name=None):# regex is a string representing a regular expression.        # callback is either a string like 'foo.views.news.stories.story_detail'      # which represents the path to a module and a view function name, or a       # callable object (view).        self.regex = re.compile(regex, re.UNICODE)       if callable(callback):               self._callback = callback        else:                self._callback = None               self._callback_str = callback            self.default_args = default_args or {}            self.name = name    def __repr__(self):          return '<%s %s %s>' % (self.__class__.__name__, self.name, self.regex.pattern)    def add_prefix(self, prefix):        """        Adds the prefix string to a string-based callback.        """            if not prefix or not hasattr(self, '_callback_str'):             return        self._callback_str = prefix + '.' + self._callback_str    def resolve(self, path):            match = self.regex.search(path)            if match:           # If there are any named groups, use those as kwargs, ignoring           # non-named groups. Otherwise, pass all non-named arguments as            # positional arguments.               kwargs = match.groupdict()               if kwargs:                       args = ()               else:                       args = match.groups()            # In both cases, pass any extra_kwargs as **kwargs.              kwargs.update(self.default_args)              return ResolverMatch(self.callback, args, kwargs, self.name)   def _get_callback(self):          if self._callback is not None:               return self._callback        try:               self._callback = get_callable(self._callback_str)        except ImportError, e:               mod_name, _ = get_mod_func(self._callback_str)               raise ViewDoesNotExist("Could not import %s. Error was: %s" % (mod_name, str(e)))        except AttributeError, e:               mod_name, func_name = get_mod_func(self._callback_str)              raise ViewDoesNotExist("Tried %s in module %s. Error was: %s" % (func_name, mod_name, str(e)))           return self._callback    callback = property(_get_callback)

 

二.二 URL分解器

通常,一个URL分解器对应一个URL配置模块,它可以包含多个URL模式,也可以包含多个其他URL分解器.通过这种包含结构设计,实现Django对URL的层级解析.

URL分解器是Django实现app与项目解耦的关键.通常由include方法操作的URL配置模块,最终会被解释成为URL分解器.

每个URL分解器都需要指定如下几个内容:

1. 一个正则表达式字符串.URL开始部分是否匹配正则表达式,如匹配,去除成功匹配部分后余下部分匹配包含的URL模式和URL分解器.
2. URL配置模块名或URL配置模块的引用.
3. 可选的关键参数(字典形式).
4. 可选的App名称.
5. 可选的名称空间名字.

类django.core.urlresolvers.RegexURLResolver用来表示URL分解器.

class RegexURLResolver(object):    def __init__(self, regex, urlconf_name, default_kwargs=None, app_name=None, namespace=None):        # regex is a string representing a regular expression.        # urlconf_name is a string representing the module containing URLconfs.        self.regex = re.compile(regex, re.UNICODE)        self.urlconf_name = urlconf_name        if not isinstance(urlconf_name, basestring):            self._urlconf_module = self.urlconf_name        self.callback = None        self.default_kwargs = default_kwargs or {}        self.namespace = namespace        self.app_name = app_name        self._reverse_dict = None        self._namespace_dict = None        self._app_dict = None    def __repr__(self):        return '<%s %s (%s:%s) %s>' % (self.__class__.__name__, self.urlconf_name, self.app_name, self.namespace, self.regex.pattern)    def _populate(self):        lookups = MultiValueDict()        namespaces = {}        apps = {}        for pattern in reversed(self.url_patterns):            p_pattern = pattern.regex.pattern            if p_pattern.startswith('^'):                p_pattern = p_pattern[1:]            if isinstance(pattern, RegexURLResolver):                if pattern.namespace:                    namespaces[pattern.namespace] = (p_pattern, pattern)                    if pattern.app_name:                        apps.setdefault(pattern.app_name, []).append(pattern.namespace)                else:                    parent = normalize(pattern.regex.pattern)                    for name in pattern.reverse_dict:                        for matches, pat in pattern.reverse_dict.getlist(name):                            new_matches = []                            for piece, p_args in parent:                                new_matches.extend([(piece + suffix, p_args + args) for (suffix, args) in matches])                            lookups.appendlist(name, (new_matches, p_pattern + pat))                    for namespace, (prefix, sub_pattern) in pattern.namespace_dict.items():                        namespaces[namespace] = (p_pattern + prefix, sub_pattern)                    for app_name, namespace_list in pattern.app_dict.items():                        apps.setdefault(app_name, []).extend(namespace_list)            else:                bits = normalize(p_pattern)                lookups.appendlist(pattern.callback, (bits, p_pattern))                if pattern.name is not None:                    lookups.appendlist(pattern.name, (bits, p_pattern))        self._reverse_dict = lookups        self._namespace_dict = namespaces        self._app_dict = apps   def _get_reverse_dict(self):        if self._reverse_dict is None:            self._populate()        return self._reverse_dict    reverse_dict = property(_get_reverse_dict)    def _get_namespace_dict(self):        if self._namespace_dict is None:            self._populate()        return self._namespace_dict    namespace_dict = property(_get_namespace_dict)    def _get_app_dict(self):        if self._app_dict is None:            self._populate()        return self._app_dict    app_dict = property(_get_app_dict)    def resolve(self, path):        tried = []        match = self.regex.search(path)        if match:            new_path = path[match.end():]            for pattern in self.url_patterns:                try:                    sub_match = pattern.resolve(new_path)                except Resolver404, e:                    sub_tried = e.args[0].get('tried')                    if sub_tried is not None:                        tried.extend([[pattern] + t for t in sub_tried])                    else:                        tried.append([pattern])                else:                    if sub_match:                        sub_match_dict = dict([(smart_str(k), v) for k, v in match.groupdict().items()])                        sub_match_dict.update(self.default_kwargs)                        for k, v in sub_match.kwargs.iteritems():                            sub_match_dict[smart_str(k)] = v                        return ResolverMatch(sub_match.func, sub_match.args, sub_match_dict, sub_match.url_name, self.app_name or sub_match.app_name, [self.namespace] + sub_match.namespaces)                    tried.append([pattern])            raise Resolver404({'tried': tried, 'path': new_path})        raise Resolver404({'path' : path})    def _get_urlconf_module(self):        try:            return self._urlconf_module        except AttributeError:            self._urlconf_module = import_module(self.urlconf_name)            return self._urlconf_module    urlconf_module = property(_get_urlconf_module)    def _get_url_patterns(self):        patterns = getattr(self.urlconf_module, "urlpatterns", self.urlconf_module)        try:            iter(patterns)        except TypeError:            raise ImproperlyConfigured("The included urlconf %s doesn't have any patterns in it" % self.urlconf_name)        return patterns    url_patterns = property(_get_url_patterns)    def _resolve_special(self, view_type):        callback = getattr(self.urlconf_module, 'handler%s' % view_type, None)        if not callback:            # No handler specified in file; use default            # Lazy import, since urls.defaults imports this file            from django.conf.urls import defaults            callback = getattr(defaults, 'handler%s' % view_type)        try:            return get_callable(callback), {}        except (ImportError, AttributeError), e:            raise ViewDoesNotExist("Tried %s. Error was: %s" % (callback, str(e)))    def resolve404(self):        return self._resolve_special('404')    def resolve500(self):        return self._resolve_special('500')    def reverse(self, lookup_view, *args, **kwargs):        if args and kwargs:            raise ValueError("Don't mix *args and **kwargs in call to reverse()!")        try:            lookup_view = get_callable(lookup_view, True)        except (ImportError, AttributeError), e:            raise NoReverseMatch("Error importing '%s': %s." % (lookup_view, e))        possibilities = self.reverse_dict.getlist(lookup_view)        for possibility, pattern in possibilities:            for result, params in possibility:                if args:                    if len(args) != len(params):                        continue                    unicode_args = [force_unicode(val) for val in args]                    candidate =  result % dict(zip(params, unicode_args))                else:                    if set(kwargs.keys()) != set(params):                        continue                    unicode_kwargs = dict([(k, force_unicode(v)) for (k, v) in kwargs.items()])                    candidate = result % unicode_kwargs                if re.search(u'^%s' % pattern, candidate, re.UNICODE):                    return candidate        # lookup_view can be URL label, or dotted path, or callable, Any of        # these can be passed in at the top, but callables are not friendly in        # error messages.        m = getattr(lookup_view, '__module__', None)        n = getattr(lookup_view, '__name__', None)        if m is not None and n is not None:            lookup_view_s = "%s.%s" % (m, n)        else:            lookup_view_s = lookup_view        raise NoReverseMatch("Reverse for '%s' with arguments '%s' and keyword "                "arguments '%s' not found." % (lookup_view_s, args, kwargs))

 

二.三 匹配结果

匹配结果是指当URL被正确匹配时,需返回的匹配结果.

匹配结果需指定以下几个内容:

1. 一个可调用对象.通常是视图函数.
2. 视图函数参数.通常是URL模式中正则表达式命名组匹配的值.
3. 视图函数关键字参数.通常是url方法中设置传递给视图函数的参数(字典形式).
4. 可选的URL名称参数.
5. 可选的APP名称参数.
6. 可选的命名空间参数.

类django.core.urlresolvers.ResolverMatch用来表示匹配结果.ResolverMatch类实现了__getitem__方法,可以同元组操作一样,获取视图函数引用与视图函数参数,

从而具备调用视图函数的条件.

class ResolverMatch(object):    def __init__(self, func, args, kwargs, url_name=None, app_name=None, namespaces=None):        self.func = func        self.args = args        self.kwargs = kwargs        self.app_name = app_name        if namespaces:            self.namespaces = [x for x in namespaces if x]        else:            self.namespaces = []        if not url_name:            if not hasattr(func, '__name__'):                # An instance of a callable class                url_name = '.'.join([func.__class__.__module__, func.__class__.__name__])            else:                # A function                url_name = '.'.join([func.__module__, func.__name__])        self.url_name = url_name    def namespace(self):        return ':'.join(self.namespaces)    namespace = property(namespace)    def view_name(self):        return ':'.join([ x for x in [ self.namespace, self.url_name ]  if x ])    view_name = property(view_name)    def __getitem__(self, index):        return (self.func, self.args, self.kwargs)[index]    def __repr__(self):        return "ResolverMatch(func=%s, args=%s, kwargs=%s, url_name='%s', app_name='%s', namespace='%s')" % (self.func, self.args, self.kwargs, self.url_name, self.app_name, self.namespace)

 

二.四 URL配置处理过程

通过对URL模式,URL分解器,URL匹配结果的了解,基本上对URL配置的处理过程了解大半了.

看看开始处理URL配置的代码:

if hasattr(request, "urlconf"):    # Reset url resolver with a custom urlconf.    urlconf = request.urlconf    urlresolvers.set_urlconf(urlconf)    resolver = urlresolvers.RegexURLResolver(r'^/', urlconf)callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)

得益于URL分解器的层级设计,这几行代码便完成了对URL配置的处理过程.

 

插播: URL匹配异常页面

在URL没有正确匹配时,Django通常会报出404错误,如果在开发模式,会展示一个异常页面,页面包括URL模块等很多内容.这个怎么实现的呢?

在使用URL分解器对URL配置进行解析的时候,如果没有完全匹配的模式,会抛出Resolver404异常.

对Resolver404异常的处理,可能就包含在上一篇文章 介绍的异常中间件中(只是猜测,有兴趣的亲可以研究一下.)