django源码分析--02url解析

回顾上一章

wsgi通过ServerHandler来执行django的应用程序,第一个落地对象是,django.contrib.staticfiles.handlers.StaticFilesHandler

class StaticFilesHandler(WSGIHandler):

    def __init__(self, application):
        self.application = application
        super(StaticFilesHandler, self).__init__()
        
    def _should_handle(self, path):
        return path.startswith(self.base_url[2]) and not self.base_url[1]
        
    def get_response(self, request):
        from django.http import Http404
        if self._should_handle(request.path):
            try:
                return self.serve(request)
            except Http404 as e:
                if settings.DEBUG:
                    from django.views import debug
                    return debug.technical_404_response(request, e)
        return super(StaticFilesHandler, self).get_response(request)
        
    def __call__(self, environ, start_response):
        if not self._should_handle(get_path_info(environ)):
            return self.application(environ, start_response)

        return super(StaticFilesHandler, self).__call__(environ, start_response)

django.contrib.staticfiles.handlers.StaticFilesHandler的作用是当请求出现时,先检查url是不是一个静态文件请求,如果是的话则进入静态文件(图片、css样式文件、js脚本文件等等)处理的view,如果不是的话则将该请求提交给Django的handler来进行处理(解析url、执行对应的view代码块、渲染和返回template)。

补充说明
__call__方法中比较有意思的是根据条件进行不同的返回。

  • self.application(environ, start_response)
    执行的是django.core.handlers.wsgi.WSGIHandler.__call__对象,对象的继承集合中不包含django.contrib.staticfiles.StaticFilesHandler,也就是说后续如果调用了self.get_response,那么它执行的是django.core.handlers.base.BaseHandler.get_response方法。
  • super(StaticFilesHandler, self).call(environ, start_response)
    虽然执行的也是django.core.handlers.wsgi.WSGIHandler.__call__对象,但是这个对象的继承集合里面包含django.contrib.staticfiles.StaticFilesHandler,因此后续如果调用了self.get_response,那么它执行的是django.contrib.staticfiles.StaticFilesHandler.get_response方法。

 
 

URL解析

django.core.handlers.wsgi.py
class WSGIHandler(base.BaseHandler):
    request_class = WSGIRequest

    def __init__(self, *args, **kwargs):
        super(WSGIHandler, self).__init__(*args, **kwargs)
        self.load_middleware()

    def __call__(self, environ, start_response):
        set_script_prefix(get_script_name(environ))
        signals.request_started.send(sender=self.__class__, environ=environ)
        try:
            request = self.request_class(environ)
        except UnicodeDecodeError:
            logger.warning(
                'Bad Request (UnicodeDecodeError)',
                exc_info=sys.exc_info(),
                extra={
                    'status_code': 400,
                }
            )
            response = http.HttpResponseBadRequest()
        else:
            response = self.get_response(request)

        response._handler_class = self.__class__

        status = '%d %s' % (response.status_code, response.reason_phrase)
        response_headers = [(str(k), str(v)) for k, v in response.items()]
        for c in response.cookies.values():
            response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
        start_response(force_str(status), response_headers)
        if getattr(response, 'file_to_stream', None) is not None and environ.get('wsgi.file_wrapper'):
            response = environ['wsgi.file_wrapper'](response.file_to_stream)
        return response

request = self.request_class(environ)负责初始化 WSGIRequest对象(这个对象有点想wsgi接口中的WSGIRequestHandler对象做的工作,针对environ进行预处理),在初始化过程中主要是在原本environ中加工处理一些django程序能读得懂的参数(例如header、PATH_INFO、REQUEST_METHOD、charset等等)。
response = self.get_response(request)正如上面的补充说明环节说明一样,针对不同请求执行不同的方法,我主要是跟常规请求而不是静态文件请求,因此这个self.get_response实际上指的是django.core.handlers.base.BaseHandler.get_response

django.core.handlers.base.py
class BaseHandler(object):

    def __init__(self):
        ...
        self._middleware_chain = None

    def load_middleware(self):
        ...

        if settings.MIDDLEWARE is None:
            ...
        else:
            handler = convert_exception_to_response(self._get_response)
            ...

        self._middleware_chain = handler

        
    def get_response(self, request):
        ...
        response = self._middleware_chain(request)  
        ...
        return response    
        
    def _get_response(self, request):
        response = None

        if hasattr(request, 'urlconf'):
            urlconf = request.urlconf
            set_urlconf(urlconf)
            resolver = get_resolver(urlconf)
        else:
            resolver = get_resolver()           # 初始化RegexURLResolver对象

        resolver_match = resolver.resolve(request.path_info)
        callback, callback_args, callback_kwargs = resolver_match
        request.resolver_match = resolver_match
        ...
        if response is None:
            wrapped_callback = self.make_view_atomic(callback)

            try:
                response = wrapped_callback(request, *callback_args, **callback_kwargs)
            except Exception as e:
                response = self.process_exception_by_middleware(e, request)
        ...
        return response        

response = self._middleware_chain(request),当执行完这行代码时,response变量就是一个html了,也就是说,所有的工作都隐藏在这行代码中。然而self._middleware_chain变量初始化的时候是None,然后在get_response方法中却可以被调用,这表明它是至少是一个方法或函数,也就是说,在调用get_response方法之前,这个self._middleware_chain变量已经被赋值过了,所以我要去找哪里有针对这个self._middleware_chain处理的地方。

  • django.core.handlers.base.BaseHandler.load_middleware方法中将convert_exception_to_response(self._get_response)赋值给了self._middleware_chain
  • convert_exception_to_response是一个装饰器,当self._get_response执行过程中遇到错误时,则try住这个错误并根据当前错误代码返回一个对应的错误信息页面。

django.core.handlers.base.BaseHandler._get_response 负责解析URL和传递参数给view。

  • resolver = get_resolver() 初始化RegexURLResolver对象。
  • resolver_match = resolver.resolve(request.path_info) 通过path_info解析url所绑定的对象,并将解析结果对象赋值给resolver_match变量。
  • callback, callback_args, callback_kwargs = resolver_match 其中callback是具体的view, callback_args是执行这个view需要提供的列表参数(类似与tornado中的self.path_args),callback_kwargs是执行这个view需要提供的字典参数。
  • wrapped_callback = self.make_view_atomic(callback)是针对数据库事务支持所封装的一个对象。
  • response = wrapped_callback(request, *callback_args, **callback_kwargs)是执行这个具体的view(request, *callback_args, **callback_kwargs)。

小结
流程性的记录了request从初始化到url解析、再到response执行和返回过程。

 
 
 

深入理解URL解析

上一节有提及到resolver = get_resolver()resolver_match = resolver.resolve(request.path_info)这两行代码,它就是理解URL解析的入口,另外一个理解URL解析的入口在项目文件的urls.py文件中(也就是我当前HelloWorld项目的HelloWorld.urls.py)。

HelloWorld.urls.py
from django.conf.urls import url    # 这里是重点
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
]

url(r'^admin/', admin.site.urls)这里采用了url()函数对正则表达式的url和视图进行包裹,反过来看就是将正则表达式url和视图当作参数传递给url()函数。
备注: admin.site.urls是一个tuple,里面包含一个url集合(另外一组urlpatterns)。

 

django.conf.urls.__init__.py
from django.urls import (
    LocaleRegexURLResolver, RegexURLPattern, RegexURLResolver,
)

def url(regex, view, kwargs=None, name=None):
    if isinstance(view, (list, tuple)):
        # For include(...) processing.
        urlconf_module, app_name, namespace = view
        return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace)
    elif callable(view):
        return RegexURLPattern(regex, view, kwargs, name)
    else:
        raise TypeError('view must be a callable or a list/tuple in the case of include().')

通过查看url()函数的定义,regex参数可以看作是r'^admin/', view参数可以看作是admin.site.urls。接下来是根据view参数的对象类型来调用不同的对象进行解析,因此这里临时插入一段代码来看看admin.site.urls。

django.contrib.admin.sites.py
class AdminSite(object):

    def __init__(self, name='admin'):
       self.name = name
        
    @property
    def urls(self):
        return self.get_urls(), 'admin', self.name

    def get_urls(self):
        from django.conf.urls import url, include

        def wrap(view, cacheable=False):
            def wrapper(*args, **kwargs):
                return self.admin_view(view, cacheable)(*args, **kwargs)
            wrapper.admin_site = self
            return update_wrapper(wrapper, view)

        urlpatterns = [
            url(r'^$', wrap(self.index), name='index'),
            url(r'^login/$', self.login, name='login'),
            url(r'^logout/$', wrap(self.logout), name='logout'),
            url(r'^password_change/$', wrap(self.password_change, cacheable=True), name='password_change'),
            url(r'^password_change/done/$', wrap(self.password_change_done, cacheable=True), name='password_change_done'),
            url(r'^jsi18n/$', wrap(self.i18n_javascript, cacheable=True), name='jsi18n'),
            url(r'^r/(?P<content_type_id>\d+)/(?P<object_id>.+)/$', wrap(contenttype_views.shortcut), name='view_on_site'),
        ]

        valid_app_labels = []
        for model, model_admin in self._registry.items():
            urlpatterns += [
                url(r'^%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.urls)),
            ]
            if model._meta.app_label not in valid_app_labels:
                valid_app_labels.append(model._meta.app_label)

        if valid_app_labels:
            regex = r'^(?P<app_label>' + '|'.join(valid_app_labels) + ')/$'
            urlpatterns += [
                url(regex, wrap(self.app_index), name='app_list'),
            ]
        return urlpatterns

site = AdminSite()

透过这个代码片段可以清晰的看到admin.site.urls 实际上是一个元祖(tuple)对象,因此会匹配到if isinstance(view, (list, tuple))条件,并执行该条件下的代码块(返回RegexURLResolver初始化后的对象)。

urlconf_module, app_name, namespace = view这里将view拆分成了三个变量(对象)。

  • urlconf_module = self.get_urls() = 整个admin的所有定义的urls.
  • app_name = 'admin' = 常量变量'admin'字符串
  • namespace = self.name = 'admin' = 常量变量'admin'字符串,由于site = AdminSite()初始化过程中并没有提供任何参数,因此采用了默认的def __init__(self, name='admin')

另外一个情况是当view是单个函数时,则会匹配到elif callable(view)并执行该条件下的代码块(返回RegexURLPattern初始化后的对象)。

小结
上面三个代码片段主要是为了接下来的django.urls.resolvers.RegexURLResolver对象的原理理解做一个铺垫,因此下面我会言归正传,接着django.core.handlers.base.BaseHandler._get_response往下走。

 

django.urls.resolvers.py
class ResolverMatch(object):
    def __init__(self, func, args, kwargs, url_name=None, app_names=None, namespaces=None):
        self.func = func
        self.args = args
        self.kwargs = kwargs
        self.url_name = url_name

        self.app_names = [x for x in app_names if x] if app_names else []
        self.app_name = ':'.join(self.app_names)
        self.namespaces = [x for x in namespaces if x] if namespaces else []
        self.namespace = ':'.join(self.namespaces)

        if not hasattr(func, '__name__'):
            self._func_path = '.'.join([func.__class__.__module__, func.__class__.__name__])
        else:
            self._func_path = '.'.join([func.__module__, func.__name__])

        view_path = url_name or self._func_path
        self.view_name = ':'.join(self.namespaces + [view_path])

    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_names=%s, namespaces=%s)" % (
            self._func_path, self.args, self.kwargs, self.url_name,
            self.app_names, self.namespaces,
        )


@lru_cache.lru_cache(maxsize=None)
def get_resolver(urlconf=None):
    if urlconf is None:
        from django.conf import settings
        urlconf = settings.ROOT_URLCONF
    return RegexURLResolver(r'^/', urlconf)


class LocaleRegexProvider(object):

    def __init__(self, regex):
        self._regex = regex
        self._regex_dict = {}

    @property
    def regex(self):
        language_code = get_language()
        if language_code not in self._regex_dict:
            regex = self._regex if isinstance(self._regex, six.string_types) else force_text(self._regex)
            try:
                compiled_regex = re.compile(regex, re.UNICODE)              # initially regex -> '^/'
            except re.error as e:
                raise ImproperlyConfigured(
                    '"%s" is not a valid regular expression: %s' %
                    (regex, six.text_type(e))
                )
            self._regex_dict[language_code] = compiled_regex
        return self._regex_dict[language_code]


class RegexURLResolver(LocaleRegexProvider):
    def __init__(self, regex, urlconf_name, default_kwargs=None, app_name=None, namespace=None):
        LocaleRegexProvider.__init__(self, regex)
        self.urlconf_name = urlconf_name
        self.callback = None
        self.default_kwargs = default_kwargs or {}
        self.namespace = namespace
        self.app_name = app_name
        self._reverse_dict = {}
        self._namespace_dict = {}
        self._app_dict = {}
        self._callback_strs = set()
        self._populated = False
        self._local = threading.local()
        
    def resolve(self, path):
        path = force_text(path)  # path may be a reverse_lazy object
        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 as 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(match.groupdict(), **self.default_kwargs)
                        sub_match_dict.update(sub_match.kwargs)
                        sub_match_args = sub_match.args
                        if not sub_match_dict:
                            sub_match_args = match.groups() + sub_match.args

                        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,
                        )
                    tried.append([pattern])
            raise Resolver404({'tried': tried, 'path': new_path})
        raise Resolver404({'path': path})

    @cached_property
    def urlconf_module(self):
        if isinstance(self.urlconf_name, six.string_types):
            return import_module(self.urlconf_name)
        else:
            return self.urlconf_name

    @cached_property
    def url_patterns(self):
        patterns = getattr(self.urlconf_module, "urlpatterns", self.urlconf_module)
        try:
            iter(patterns)
        except TypeError:
            msg = (
                "The included URLconf '{name}' does not appear to have any "
                "patterns in it. If you see valid patterns in the file then "
                "the issue is probably caused by a circular import."
            )
            raise ImproperlyConfigured(msg.format(name=self.urlconf_name))
        return patterns        

django.core.handlers.base.BaseHandler._get_response方法中通过resolver = get_resolver()来初始化RegexURLResolver对象,它调用了当前代码片段中的get_resolver,返回值是RegexURLResolver(r'^/', urlconf)相当于RegexURLResolver(r'^/', 'HelloWorld.urls')。

  • RegexURLResolver.__init__
    初始化过程中,会将r'^/'赋值给self._regex(以super的形式在父类中赋值),将'HelloWorld.urls'赋值给self.urlconf_name

  • RegexURLResolver.urlconf_module
    利用python Lib库中的高级特性import_module,先创建一个空的对象,然后将'HelloWorld.urls'这个字符串当作一个模块文件来执行,并将所有出现在这个模块文件中的变量以attribute的形式set到这个对象中,最后把这个对象返回给调用者。
    通过上面提供的HelloWorld.urls.py文件代码块的内容可以看的出来, urlpatterns 是一个列表对象(变量),还有url和admin这两个对象(变量),因此这个import_module创建的变量就包含了urlpatterns、url、admin这三个attribute。

  • RegexURLResolver.url_patterns
    这个方法调用了urlconf_module方法,然后提取出urlpatterns的值,最后把这个值返回给调用者。

django.core.handlers.base.BaseHandler._get_response 方法中通过resolver_match = resolver.resolve(request.path_info)来返回url解析结果,该url解析结果包含了对应的view、该view执行需要用到的args和该view执行需要用到的kwargs。resolver.resolve(request.path_info)相当于是RegexURLResolver(r'^/', 'HelloWorld.urls').resolve(request.path_info)

  • RegexURLResolver.resolve 这个函数非常烧脑,我尽量列详细记录,避免以后忘了可以再过来看快速记起来。

    • path = force_text(path) 将路径强制转换成字符串.

    • tried = [] 用于记录已解析对象(路径).

    • match = self.regex.search(path)
      通过继承对象LocaleRegexProvider.regex方法来匹配路径,由于整个当前对象RegexURLResolver初始化时,传递的参数是'^/',因此不论请求过来的URL是什么,都会匹配成功,因此if match是肯定通过的。它还有另外一层作用(职责),就是专门负责匹配到'模块',例如: 请求的url是</admin/auth/user/>,那么它将会匹配到'^/'。

    • new_path = path[match.end():]
      这行代码的用意是将上级匹配到的'模块'给移除掉。

    • for pattern in self.url_patterns
      这里self.url_patterns返回的是一个包裹了HelloWorld.urls的 RegexURLResolver 对象集合(由于我没有自定义填写任何新的url,因此它只有[url(r'^admin/', admin.site.urls)],经过url这个函数执行过后,它实际上返回的是这么一个东西:[<RegexURLResolver <RegexURLPattern list> (admin:admin) ^admin/>])。
      通过for循环将这个[<RegexURLResolver <RegexURLPattern list> (admin:admin) ^admin/>]进行分解,其实当前状态下列表只有一个元素,因此这个for循环只会执行一次,但是它的作用不止于此,还需要耐心往下看。

    • sub_match = pattern.resolve(new_path)
      在这里,这个pattern就是<RegexURLResolver <RegexURLPattern list> (admin:admin) ^admin/>这个对象,pattern.resolve相当于RegexURLResolver.resolve,看起来像是自己把自己再次调用了一遍死循环的节奏,但是由于pattern是外部重新实例化的一个对象,因此这里并不是递归,也不是死循环。

      admin.site.urls == <RegexURLResolver <RegexURLPattern list> (admin:admin) ^admin/>,再次执行上面所提到的代码,但是当再次遇到for pattern in self.url_patterns返回的对象就不一样了,这次它返回的是下面这些对象(为什么会是这些东西,请看前面有列出来的get_urls()的源码):

      [
      <RegexURLPattern index ^$>,
      <RegexURLPattern login ^login/$>,
      <RegexURLPattern logout ^logout/$>,
      <RegexURLPattern password_change ^password_change/$>,
      <RegexURLPattern password_change_done ^password_change/done/$>,
      <RegexURLPattern jsi18n ^jsi18n/$>,
      <RegexURLPattern view_on_site ^r/(?P<content_type_id>\d+)/(?P<object_id>.+)/$>,
      <RegexURLResolver <RegexURLPattern list> (None:None) ^auth/group/>,
      <RegexURLResolver <RegexURLPattern list> (None:None) ^auth/user/>,
      <RegexURLPattern app_list ^(?P<app_label>auth)/$>
      ]

      这次pattern.resolve的对象就不一样了,当pattern对象是RegexURLPattern时,执行的其实RegexURLPattern.resolve,它的作用是利用每个RegexURLPattern中的正则表达式来匹配被裁(new_path = path[match.end():])剪过的url; 当pattern对象还是RegexURLResolver时,再去找到该对象下的所有urlpatterns集合。

    • 剩下的就不是很难,所以就不列出来了。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 203,456评论 5 477
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 85,370评论 2 381
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 150,337评论 0 337
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 54,583评论 1 273
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 63,596评论 5 365
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 48,572评论 1 281
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 37,936评论 3 395
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,595评论 0 258
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 40,850评论 1 297
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,601评论 2 321
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,685评论 1 329
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,371评论 4 318
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 38,951评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,934评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,167评论 1 259
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 43,636评论 2 349
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,411评论 2 342

推荐阅读更多精彩内容