当前位置: 首页>编程语言>正文

url配置currentSchema不生效 url配置是什么意思

一 什么是URL配置

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

执行 django-admin.py startproject 时,该脚本会自动为你建了一份 URLconf(即 urls.py

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

二 Django如何处理URL配置

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

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


https://www.xamrdz.com/lan/5da1960308.html

相关文章: