Flask源码(4)__请求上下文

小灰灰 2022-05-28 10:05 190阅读 0赞

## 前景 ##

前天看了上下文的栈实现，今天看看请求上下文和应用上下文的流程

## 请求上下文 ##

wsgi\_app中的一小段关于请求上下文的代码

ctx = self.request_context(environ)
        ctx.push()

**request\_context**

def request_context(self, environ):
            """从提供的环境中创建一个类-请求上下文，并且绑定到当前上下文上."""  
            return RequestContext(self, environ)

可以看到，它返回的是RequestContext对象

**RequestContext**

""" 请求上下文包含所有请求相关的信息，在请求一开始的时候创建，然后进入_request_ctx_stack栈中，在结束的时候移除。它会创建一个URL适配器和基于WSGI环境的请求对象。 不要直接使用这个类，而是使用Flask.test_request_context和Flask.request_context 当请求上下文出栈的时候，它会执行所有注册在Flask.teardown_request上面的函数 """
        def __init__(self, app, environ, request=None):
            self.app = app
            if request is None:
                # 创建一个Request对象，保存环境
                request = app.request_class(environ)
            self.request = request
            # 创建一个URL适配器
            self.url_adapter = app.create_url_adapter(self.request)
            self.flashes = None
            # session也包含在请求上下文中
            self.session = None
    
            # Request 上下文可能被多次压入站，并且和其它request上下文交错在一起，只有最后一层的被pop我们才能处理他们。另外 如果一个应用上下文缺少的话，会隐式地为每一层请求上下文创建一个应用上下文
            self._implicit_app_ctx_stack = []
    
            # 指示器，用来指示上下文是否要保存. 下一次另一个上下文被压入的时候，这个上下文会被弹出.
            self.preserved = False
            self._preserved_exc = None
        # 在request之后需要在response对象上需要被执行的函数，它们会在常规的after_request之前被调用
            self._after_request_functions = []
    
            self.match_request()
    
        def _get_g(self):
            return _app_ctx_stack.top.g
        def _set_g(self, value):
            _app_ctx_stack.top.g = value
        # 用装饰器 将g作为属性
        g = property(_get_g, _set_g)
        del _get_g, _set_g
    
        def copy(self):
            """使用相同的请求对象创建一个请求上下文的拷贝，可以用来将 一个请求上下文移动到不同的greenlet（协程)，因为实际的请求对象是一样的，所以不能用来移动到不同的线程中，除非加锁。 """
            return self.__class__(self.app,
                environ=self.request.environ,
                request=self.request
            )
    
        def match_request(self):
            """Can be overridden by a subclass to hook into the matching of the request. """
            try:
                url_rule, self.request.view_args = \
                    self.url_adapter.match(return_rule=True)
                self.request.url_rule = url_rule
            except HTTPException as e:
                self.request.routing_exception = e
    
        def push(self):
            """绑定请求上下文到当前的上下文中"""
            # If an exception occurs in debug mode or if context preservation is
            # activated under exception situations exactly one context stays
            # on the stack. The rationale is that you want to access that
            # information under debug situations. However if someone forgets to
            # pop that context again we want to make sure that on the next push
            # it's invalidated, otherwise we run at risk that something leaks
            # memory. This is usually only a problem in test suite since this
            # functionality is not active in production environments.
            top = _request_ctx_stack.top
            if top is not None and top.preserved:
                top.pop(top._preserved_exc)
    
            # 在请求上下文入栈前需要保证将有一个应用上下文
            app_ctx = _app_ctx_stack.top
            # 如果app_ctx是空或者不是当前的app，隐式上下文加入app_ctx
            if app_ctx is None or app_ctx.app != self.app:
                app_ctx = self.app.app_context()
                app_ctx.push()
                self._implicit_app_ctx_stack.append(app_ctx)
            else:
                # 如果top是当前的应用，隐式的上下文栈进入None
                self._implicit_app_ctx_stack.append(None)
    
            if hasattr(sys, 'exc_clear'):
                sys.exc_clear()
        # 请求上下文入栈
            _request_ctx_stack.push(self)
        # 当请求上下文可以被获取的时候打开session，这允许open_session方法来使用request ctx
            self.session = self.app.open_session(self.request)
            if self.session is None:
                self.session = self.app.make_null_session()
    
        def pop(self, exc=_sentinel):
            """弹出请求上下文，并且解除绑定，并且会触发注册在teardown_request的函数 """
            app_ctx = self._implicit_app_ctx_stack.pop()
    
            try:
                clear_request = False
                if not self._implicit_app_ctx_stack:
                    self.preserved = False
                    self._preserved_exc = None
                    if exc is _sentinel:
                        exc = sys.exc_info()[1]
                    self.app.do_teardown_request(exc)
    
                    # If this interpreter supports clearing the exception information
                    # we do that now. This will only go into effect on Python 2.x,
                    # on 3.x it disappears automatically at the end of the exception
                    # stack.
                    if hasattr(sys, 'exc_clear'):
                        sys.exc_clear()
    
                    request_close = getattr(self.request, 'close', None)
                    if request_close is not None:
                        request_close()
                    clear_request = True
            finally:
                rv = _request_ctx_stack.pop()
    
                # get rid of circular dependencies at the end of the request
                # so that we don't require the GC to be active.
                if clear_request:
                    rv.request.environ['werkzeug.request'] = None
    
                # Get rid of the app as well if necessary.
                if app_ctx is not None:
                    app_ctx.pop(exc)
    
                assert rv is self, 'Popped wrong request context. ' \
                    '(%r instead of %r)' % (rv, self)
    
        def auto_pop(self, exc):
            if self.request.environ.get('flask._preserve_context') or \
               (exc is not None and self.app.preserve_context_on_exception):
                self.preserved = True
                self._preserved_exc = exc
            else:
                self.pop(exc)
    
        def __enter__(self):
            self.push()
            return self
    
        def __exit__(self, exc_type, exc_value, tb):
            # do not pop the request stack if we are in debug mode and an
            # exception happened. This will allow the debugger to still
            # access the request object in the interactive shell. Furthermore
            # the context can be force kept alive for the test client.
            # See flask.testing for how this works.
            self.auto_pop(exc_value)
    
            if BROKEN_PYPY_CTXMGR_EXIT and exc_type is not None:
                reraise(exc_type, exc_value, tb)
    
        def __repr__(self):
            return '<%s \'%s\' [%s] of %s>' % (
                self.__class__.__name__,
                self.request.url,
                self.request.method,
                self.app.name,
            )

## Request类 ##

由上次学习，我们知道request其实就是上下文栈中的某个上下文对象里面的属性，在上面的request\_ctx代码中有这样一段

if request is None: # app.request_class是Request类，这个下来详细讲解 # 所以创建了一个请求的Request对象 request = app.request_class(environ) self.request = request

在这段代码中创建了一个Request对象。app.request\_class在app中request\_class = Request。这个类在flask.wrappers里面  
**Request**  
哈哈- -我不太看得懂，总的来说就是各种参数把，包括路径，方法，参数等等

## 总结 ##

到这里基本上流程就梳理完了，细节部分之后再看，包括路由，response等。附上一张总结图，不容易 总算理清点了，不枉我几天的努力啊～还是挺开心的，明天继续～要做的事情有点多啊～，每天固定两个小时源码还是收获很大的，要坚持下去！  
![这里写图片描述][70]

[70]: /images/20220528/a8d4f3fb6a63490cb10c6512c6092418.png