Flask中的AppContext和RequestContext
前面分析app.run()背后产生的一系列调用时，说明底层代码会负责接收客户端连接，解析客户请求，并调用编写好的app(要求app是可调用对象)。调用app时， 实际调用的是app.wsgi_app方法，代码如下：
def wsgi_app(self, environ, start_response): ctx = self.request_context(environ) error = None try: try: ctx.push() response = self.full_dispatch_request() except Exception as e: error = e response = self.handle_exception(e) except: error = sys.exc_info()[1] raise return response(environ, start_response) finally: if self.should_ignore_error(error): error = None ctx.auto_pop(error)
可以发现在处理用户请求之前，语句ctx = self.request_context(environ)根据传入的environ参数创建了rctx对象，这就是RequestContext对象。
class RequestContext(object): def __init__(self, app, environ, request=None): self.app = app if request is None: request = app.request_class(environ) self.request = request self.url_adapter = app.create_url_adapter(self.request) self.flashes = None self.session = None
self._implicit_app_ctx_stack = [] self.preserved = False self._preserved_exc = None 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 = property(_get_g, _set_g) del _get_g, _set_g 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): """Binds the request context to the current context.""" # 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) # Before we push the request context we have to ensure that there # is an application context. app_ctx = _app_ctx_stack.top 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: self._implicit_app_ctx_stack.append(None) if hasattr(sys, 'exc_clear'): sys.exc_clear() _request_ctx_stack.push(self) # Open the session at the moment that the request context is available. # This allows a custom open_session method to use the request context. # Only open a new session if this is the first time the request was # pushed, otherwise stream_with_context loses the session. if self.session is None: session_interface = self.app.session_interface self.session = session_interface.open_session( self.app, self.request ) if self.session is None: self.session = session_interface.make_null_session(self.app) def pop(self, exc=_sentinel): """Pops the request context and unbinds it by doing that. This will also trigger the execution of functions registered by the :meth:`~flask.Flask.teardown_request` decorator. .. versionchanged:: 0.9 Added the `exc` argument. """ 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, )
__init__初始化方法为实例添加各种属性，注意request，session，flash属性，这些属性在编写app时经常用到。request是根据传入的environ参数新建的app.request_class类实例，打包好了所有的请求信息。session后面会讲解
创建好RequestContext实例rctx后，会调用rctx.push方法将rctx入栈。push方法先检查_request_ctx_stack种是否有之前保留的RequestContext对象，如果有的话将其出栈。什么情况下处理一个请求时，栈中会保留上一个请求的RequestContext，后文解释。接着程序判断_app_ctx_stack是否为空，如果为空或者栈头的AppContext对象绑定的app和自己绑定的app不是同一个app，则需要新建一个AppContext对象。新建AppContext对象actx后，会将actx入栈，并且在self._implicit_app_ctx_stack.append队列中记录自己创建的AppContext对象。然后rctx将自己入栈。
由此我们知道，flask中有两个栈_request_ctx_stack和_app_ctx_stack，分别用来保存请求环境和app环境。在处理一个请求时要保证两个栈的栈顶元素是和该请求对应的。
在app.wsgi_app方法中，处理完请求后，会调用ctx.auto_pop(error)将rctx出栈。
在auto_pop中我们可以看到rctx被保留在栈中的原因：
1. 最初用来创建请求的environ.flask._preserve_context属性被置位
2. 处理请求时产生异常，并且app.preserve_context_on_exception被置位
我认为常见的原因是第二个，就是在发生异常时，为了调试程序方便，任然在栈中保留请求环境，调试人员可以看到发生异常时app和请求的各种信息。这种指定一般用在开发app的时候，在生产环境中不会用到。
如果上面的两种情况没有发生将会调用pop方法，在pop中，先查看_implicit_app_ctx_stack属性，这样可以知道rctx入栈的时候自动创建的actx。之后的finally语句保证了rctx和actx会被出栈。