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异常的处理,可能就包含在上一篇文章 介绍的异常中间件中(只是猜测,有兴趣的亲可以研究一下.)