上文说到Flask的本地WSGI Server建立，WSGI Server 监听本地端口，当有请求进入时会触发WSGIRequestHandler，WSGIRequestHandler会触发Flask app实例，这样Server，Request，APP实例就建立起了关系，本文从app实例被触发说起，谈谈Flask的上下文管理。
一 请求到来前，入栈
从上文的分析中可以知道，WSGIRequestHandler会触发app实例，其实就是Flask 类中的__call__方法，我们从这个call开始。
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
call 调用了wsgi_app
def wsgi_app(self, environ, start_response):
ctx = self.request_context(environ)
try:
try:
ctx.push()
ctx = self.request_context(environ)
def request_context(self, environ):
return RequestContext(self, environ)
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
ctx其实就是一个RequestContext对象,里面包含request,session,app
再看这一句request = app.request_class(environ)，app.request_class来自flask.app.Flask中的request_class = Request
class Request(RequestBase, JSONMixin):
到这里基本可以知道，其实ctx就是一步一步封装起来的Request对象。
再来看wsgi_app这个方法，封装了ctx对象后，紧接着就是ctx.push()。我们重点来分析下这个push方法。
flask.ctx
def push(self):
top = _request_ctx_stack.top
_request_ctx_stack.push(self)
top = _request_ctx_stack.top这个操作是从_request_ctx_stack栈里取一个对象。从
Flask源码剖析二之本地栈的建立可知，此时_request_ctx_stack是一个空字典，top = None。_request_ctx_stack.push(self) 是将ctx也就是将requestContext对象入栈。
入栈过程：
_request_ctx_stack.push(self)就是执行的LocalStack类中的push方法
werkzeug.local.LocalStack
class LocalStack(object):
def __init__(self):
self._local = Local()
def push(self, obj):
"""Pushes a new item to the stack"""
rv = getattr(self._local, "stack", None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)
return rv
rv = getattr(self._local, "stack", None)当请求第一次进来时栈为空，返回一个None
self._local.stack = rv = [] 。self._local 是Local()的一个对象。
werkzeug.local. Local
class Local(object):
__slots__ = ("__storage__", "__ident_func__")
def __init__(self):
object.__setattr__(self, "__storage__", {})
object.__setattr__(self, "__ident_func__", get_ident)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
self._local.stack = [] 触发执行了Local()对象的setattr方法。 ident = self.ident_func()拿到的是当前线程或协程的ID，这个一个以为表示，每个请求的request对象都保存自己的ID里，这样就做到了线程隔离。
storage[ident][name] = value 其实就是向本地栈的空字典_request_ctx_stack里写值
self._local.stack = []执行后，_request_ctx_stack = {唯一ID:{'stack': []}}。
if rv is None:
self._local.stack = rv = []
rv.append(obj)
这就执行后_request_ctx_stack = {唯一ID:{'stack': [RequestContext(ctx)]}}
_request_ctx_stack 中现在已经有值了，值是请求上下文对象ctx 。所以总结起来ctx.push就是把请求上下文对象写入_request_ctx_stack中。
清楚了请求上下文，应用上下文和请求上下文是一个套路。
_app_ctx_stack = {唯一ID:{'stack': [AppContext(app_ctx)]}}
简单看一下应用上下文的入栈流程
flask.ctx
class RequestContext(object):
def push(self):
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()
app_ctx = _app_ctx_stack.top同样的请求第一次进来，_app_ctx_stack为空。app_ctx = None
app_ctx = self.app.app_context() 这句获取app上下文对象。
def app_context(self):
return AppContext(self)
class AppContext(object):
def __init__(self, app):
self.app = app
self.url_adapter = app.create_url_adapter(None)
self.g = app.app_ctx_globals_class()
这里app_ctx就是一个AppContext对象。里面包含app和g
app_ctx.push() 这句其实和请求上下文中的ctx.push()是一样的逻辑。只不过app_ctx用的是_app_ctx_stack栈，_app_ctx_stack = LocalStack() 这个栈的结构和_request_ctx_stack栈是一样的。 后面的push操作可以参考_request_ctx_stack.push()。
二 请求到来，执行视图函数
在视图函数中对上下文操作
@app.route('/')
def index():
print(request.args)
对这个函数只做 print(request.args)，在flask.globals中
request = LocalProxy(partial(_lookup_req_object, 'request'))，request是个LocalProxy对象，同时将偏函数partial(_lookup_req_object, 'request') 传给LocalProxy。
class LocalProxy(object):
def __init__(self, local, name=None):
object.__setattr__(self, "_LocalProxy__local", local)
在LocalProxy中self.__LocalProxy__local = partial(_lookup_req_object, 'request'),
self.__LocalProxy__local 其实就是self.__local。所以self.__local = partial(_lookup_req_object, 'request')其实也就是 self.__local = _lookup_req_object('request')。
当执行request.args是执行了LocalProxy的getattr，向LocalProxy传了2个参数，local= _lookup_req_object('request'), name = args
def __getattr__(self, name):
if name == "__members__":
return dir(self._get_current_object())
return getattr(self._get_current_object(), name)
self._get_current_object()执行了
def _get_current_object(self):
"""Return the current object. This is useful if you want the real
object behind the proxy at a time for performance reasons or because
you want to pass the object into a different context.
"""
if not hasattr(self.__local, "__release_local__"):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
从上面的分析可以知道self.__local = _lookup_req_object('request')，所以getattr(self.__local, self.name) 就是getattr(_lookup_req_object('request'),args) ,再看_lookup_req_object这函数
def _lookup_req_object(name):
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name)
这是一个全局函数，是从_request_ctx_stack栈顶的请求上下文对象ctx中取一个叫request的对象。拿到request对象后再执行
def __getattr__(self, name):
return getattr(self._get_current_object(), name)
返回的结果是getattr(request,args) 从request对象里面取args。
三 请求结束
def wsgi_app(self, environ, start_response):
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
在wsgi_app方法里可以看到请求最后都会调用ctx.auto_pop来结束
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)
auto_pop最终调用pop方法,将对象移除。
def pop(self, exc=_sentinel):
finally:
rv = _request_ctx_stack.pop()
if app_ctx is not None:
app_ctx.pop(exc)
