0、写在前面
通过阅读Flask的源码来学习下运行原理
1、启动，从请求到响应的过程
一个最简单的程序HelloWrold.py
1 from flask import Flask 2 3 app = Flask(__name__) 4 5 @app.route('/') 6 def hello_world(): 7 return 'Hello World!' 8 9 if __name__ == '__main__': 10 app.run()
可以看到，主要运行服务的代码只有2行
实例化 app = Flask(__name__)
运行 app.run()
实例化FLASK后，运行其中的run函数
run函数中的代码，传入一些配置参数后，实际运行的是werkzeug.serving.run_simple(host, port, self, **options)
Flask的底层运行的服务实际是调用werkzeug.serving.run_simple()后做了一些封装
run_simple()传入的self就是app，而且会以app()的形式运行
app()相当于执行app.__call__()
1 def run(self, host=None, port=None, debug=None, 2 load_dotenv=True, **options): 3 from werkzeug.serving import run_simple 4 5 try: 6 run_simple(host, port, self, **options) 7 finally: 8 self._got_first_request = False
app.__call__()，执行了一行self.wsgi_app(environ, start_response)
按照wsgi协议，
environ：一个包含所有HTTP请求信息的dict对象
start_response：一个发送HTTP响应的函数
1 def __call__(self, environ, start_response): 2 return self.wsgi_app(environ, start_response)
environ被经过一系列封装处理后，最终返回了封装了request和session的Request类的对象，赋值给ctx
这个ctx即为请求上下文，下文中再说
最后返回response(environ, start_response)
1 def wsgi_app(self, environ, start_response): 2 ctx = self.request_context(environ) 3 error = None 4 try: 5 try: 6 ctx.push() 7 response = self.full_dispatch_request() 8 except Exception as e: 9 error = e 10 response = self.handle_exception(e) 11 except: 12 error = sys.exc_info()[1] 13 raise 14 return response(environ, start_response) 15 finally: 16 if self.should_ignore_error(error): 17 error = None 18 ctx.auto_pop(error)
然后进入full_dispatch_request(self)
执行 self.try_trigger_before_first_request_functions()即装饰器@before_first_request装饰所有函数
执行 rv = self.preprocess_request()方法 即@before_request装饰所有函数
return self.finalize_request(rv)方法 即@after_request装饰所有函数
进入self.finalize_request(rv)，response = self.process_response(response)
1 def full_dispatch_request(self): 2 self.try_trigger_before_first_request_functions() 3 try: 4 request_started.send(self) 5 rv = self.preprocess_request() 6 if rv is None: 7 rv = self.dispatch_request() 8 except Exception as e: 9 rv = self.handle_user_exception(e) 10 return self.finalize_request(rv)
从请求上下文栈中取出request，进行路由匹配，执行视图函数
1 def dispatch_request(self): 2 req = _request_ctx_stack.top.request 3 if req.routing_exception is not None: 4 self.raise_routing_exception(req) 5 rule = req.url_rule 6 if getattr(rule, 'provide_automatic_options', False) 7 and req.method == 'OPTIONS': 8 return self.make_default_options_response() 9 return self.view_functions[rule.endpoint](**req.view_args)
2、路由
通过HelloWrold.py可以看到路由是通过一个装饰器@app.route('/')添加进来的
找个装饰器实际运行的代码self.add_url_rule(rule, endpoint, f, **options)
1 def route(self, rule, **options): 2 def decorator(f): 3 endpoint = options.pop('endpoint', None) 4 self.add_url_rule(rule, endpoint, f, **options) 5 return f 6 return decorator
endpoint是路由的唯一标识，如果为空，则把函数名赋值给endpoint
实际添加路由的self.url_map.add(rule)，该函数来自于self.url_map= werkzeug.routing.Map()，在这里进行路由的添加
路由分发上文中有
1 @setupmethod 2 def add_url_rule(self, rule, endpoint=None, view_func=None, 3 if endpoint is None: 4 endpoint = _endpoint_from_view_func(view_func) 5 options['endpoint'] = endpoint 6 methods = options.pop('methods', None) 7 8 rule = self.url_rule_class(rule, methods=methods, **options) 9 rule.provide_automatic_options = provide_automatic_options 10 11 self.url_map.add(rule) 12 if view_func is not None: 13 old_func = self.view_functions.get(endpoint) 14 if old_func is not None and old_func != view_func: 15 raise AssertionError('View function mapping is overwriting an ' 16 'existing endpoint function: %s' % endpoint) 17 self.view_functions[endpoint] = view_func
3、本地上下文
FLask上下文包含两种，请求上下文（ctx）、程序上下文（ctx_app），原理相同。
包括全局变量request、session、current_app、g
都是通过本地代理LocalProxy来实例化出来的
1 _request_ctx_stack = LocalStack() 2 _app_ctx_stack = LocalStack() 3 current_app = LocalProxy(_find_app) 4 request = LocalProxy(partial(_lookup_req_object, 'request')) 5 session = LocalProxy(partial(_lookup_req_object, 'session')) 6 g = LocalProxy(partial(_lookup_app_object, 'g'))
3.1 全局变量
reques 全局请求对象t
session 全局session对象
current_app 当前app实例
g 一个可存值的对象
全局变量通过本地代理LocalProxy(local)生成
传入具体对象，例如request，在通过代理从request中取值
上下文的push和pop是动态进行的
使用代理来取值，可以拥有动态的获取上下文对象的能力
1 class LocalProxy(object): 2 3 __slots__ = ('__local', '__dict__', '__name__', '__wrapped__') 4 5 def __init__(self, local, name=None): 6 object.__setattr__(self, '_LocalProxy__local', local) 7 object.__setattr__(self, '__name__', name) 8 if callable(local) and not hasattr(local, '__release_local__'): 9 # "local" is a callable that is not an instance of Local or 10 # LocalManager: mark it as a wrapped function. 11 object.__setattr__(self, '__wrapped__', local) 12 13 def _get_current_object(self): 14 if not hasattr(self.__local, '__release_local__'): 15 return self.__local() 16 try: 17 return getattr(self.__local, self.__name__) 18 except AttributeError: 19 raise RuntimeError('no object bound to %s' % self.__name__) 20 21 @property 22 def __dict__(self): 23 try: 24 return self._get_current_object().__dict__ 25 except RuntimeError: 26 raise AttributeError('__dict__')
request、session的偏函数partial(_lookup_req_object, name)
传入对应的name，从请求上下文中获取具体的对象
1 def _lookup_req_object(name): 2 top = _request_ctx_stack.top 3 if top is None: 4 raise RuntimeError(_request_ctx_err_msg) 5 return getattr(top, name)
g的偏函数partial_lookup_app_object(name)
从程序上下文中获取具体的对象
1 def _lookup_app_object(name): 2 top = _app_ctx_stack.top 3 if top is None: 4 raise RuntimeError(_app_ctx_err_msg) 5 return getattr(top, name)
current_app从程勋上下文获取当前的app
1 def _find_app(): 2 top = _app_ctx_stack.top 3 if top is None: 4 raise RuntimeError(_app_ctx_err_msg) 5 return top.app
3.2 请求上下文
根据上文中的请求响应过程，请求进来后先wsgi_app()
创建了ctx上下文，从上文中得知ctx是封装了request和session的Request类的对象，然后执行push()
1 def wsgi_app(self, environ, start_response): 2 ctx = self.request_context(environ) 3 ctx.push()
这是ctx.push()的代码
实际运行了_request_ctx_stack.push()
进行了各种栈操作，再看看_request_ctx_stack栈是如何工作的
1 def push(self): 2 top = _request_ctx_stack.top 3 if top is not None and top.preserved: 4 top.pop(top._preserved_exc) 5 app_ctx = _app_ctx_stack.top 6 if app_ctx is None or app_ctx.app != self.app: 7 app_ctx = self.app.app_context() 8 app_ctx.push() 9 self._implicit_app_ctx_stack.append(app_ctx) 10 else: 11 self._implicit_app_ctx_stack.append(None) 12 13 if hasattr(sys, 'exc_clear'): 14 sys.exc_clear() 15 16 _request_ctx_stack.push(self) 17 18 if self.session is None: 19 session_interface = self.app.session_interface 20 self.session = session_interface.open_session( 21 self.app, self.request 22 ) 23 24 if self.session is None: 25 self.session = session_interface.make_null_session(self.app)
运行_request_ctx_stack.push(self,obj)
self._local.stack = rv = []，再rv.append(obj)，此时obj即为ctx
_request_ctx_stack栈中的各种操作实际都依赖于Local类，再向上看看Local类
1 class LocalStack(object): 2 3 def __init__(self): 4 self._local = Local() 5 6 def __release_local__(self): 7 self._local.__release_local__() 8 9 def _get__ident_func__(self): 10 return self._local.__ident_func__ 11 12 def _set__ident_func__(self, value): 13 object.__setattr__(self._local, '__ident_func__', value) 14 __ident_func__ = property(_get__ident_func__, _set__ident_func__) 15 del _get__ident_func__, _set__ident_func__ 16 17 def __call__(self): 18 def _lookup(): 19 rv = self.top 20 if rv is None: 21 raise RuntimeError('object unbound') 22 return rv 23 return LocalProxy(_lookup) 24 25 def push(self, obj): 26 """Pushes a new item to the stack""" 27 rv = getattr(self._local, 'stack', None) 28 if rv is None: 29 self._local.stack = rv = [] 30 rv.append(obj) 31 return rv 32 33 def pop(self): 34 """Removes the topmost item from the stack, will return the 35 old value or `None` if the stack was already empty. 36 """ 37 stack = getattr(self._local, 'stack', None) 38 if stack is None: 39 return None 40 elif len(stack) == 1: 41 release_local(self._local) 42 return stack[-1] 43 else: 44 return stack.pop() 45 46 @property 47 def top(self): 48 """The topmost item on the stack. If the stack is empty, 49 `None` is returned. 50 """ 51 try: 52 return self._local.stack[-1] 53 except (AttributeError, IndexError): 54 return None
Local类构造函数中定义了两个熟悉，__storage__和__ident_func__
__ident_func__是一个获取当前线程ID的函数
__storage__是一个嵌套的字典
对Local实例进行添加属性时，调用__setattr__()，__storage__的值变为{ ident:{ name:value } }，即{ 线程ID: { 名称：实际数据 } }
对Local实例进行获取属性时，调用__getattr__()，根据线程ID和属性名进行取值self.__storage__[self.__ident_func__()][name]
1 class Local(object): 2 __slots__ = ('__storage__', '__ident_func__') 3 4 def __init__(self): 5 object.__setattr__(self, '__storage__', {}) 6 object.__setattr__(self, '__ident_func__', get_ident) 7 8 def __iter__(self): 9 return iter(self.__storage__.items()) 10 11 def __call__(self, proxy): 12 """Create a proxy for a name.""" 13 return LocalProxy(self, proxy) 14 15 def __release_local__(self): 16 self.__storage__.pop(self.__ident_func__(), None) 17 18 def __getattr__(self, name): 19 try: 20 return self.__storage__[self.__ident_func__()][name] 21 except KeyError: 22 raise AttributeError(name) 23 24 def __setattr__(self, name, value): 25 ident = self.__ident_func__() 26 storage = self.__storage__ 27 try: 28 storage[ident][name] = value 29 except KeyError: 30 storage[ident] = {name: value} 31 32 def __delattr__(self, name): 33 try: 34 del self.__storage__[self.__ident_func__()][name] 35 except KeyError: 36 raise AttributeError(name)
最后ctx.push()进行的操作实际上是_request_ctx_stack栈添加了属性{ __storage__ : { 线程ID1 : { stack : [ctx] } } }
如果是多线程运行的时候数据就是{ __storage__ : { 线程ID1 : { stack : [ctx] } , 线程ID2 : { stack : [ctx] } , 线程ID3 : { stack : [ctx] } } }
每个线程有一个独立的栈，栈中保存的全局变量request和session为每个单独线程使用，这样就保证了线程安全
在请求进来时将request和session入栈，在生成响应后出栈
3.3 程序上下文
程序上下文的生命周期伴随请求上下文的产生和销毁
每个请求都会创建新的请求上下文栈，同时会创建新的程序上下文栈
AppContext，于请求上下文类似
1 class AppContext(object): 2 def __init__(self, app): 3 self.app = app 4 self.url_adapter = app.create_url_adapter(None) 5 self.g = app.app_ctx_globals_class() 6 self._refcnt = 0 7 8 def push(self): 10 self._refcnt += 1 11 if hasattr(sys, 'exc_clear'): 12 sys.exc_clear() 13 _app_ctx_stack.push(self) 14 appcontext_pushed.send(self.app) 15 16 def pop(self, exc=_sentinel): 17 """Pops the app context.""" 18 try: 19 self._refcnt -= 1 20 if self._refcnt <= 0: 21 if exc is _sentinel: 22 exc = sys.exc_info()[1] 23 self.app.do_teardown_appcontext(exc) 24 finally: 25 rv = _app_ctx_stack.pop() 26 assert rv is self, 'Popped wrong app context. (%r instead of %r)' 27 % (rv, self) 28 appcontext_popped.send(self.app) 29 30 def __enter__(self): 31 self.push() 32 return self 33 34 def __exit__(self, exc_type, exc_value, tb): 35 self.pop(exc_value) 36 37 if BROKEN_PYPY_CTXMGR_EXIT and exc_type is not None: 38 reraise(exc_type, exc_value, tb)
app_ctx在请求上下文push()时创建app_ctx = _app_ctx_stack.top
1 class RequestContext(object): 2 def push(self): 3 app_ctx = _app_ctx_stack.top 4 if app_ctx is None or app_ctx.app != self.app: 5 app_ctx = self.app.app_context() 6 app_ctx.push() 7 self._implicit_app_ctx_stack.append(app_ctx) 8 else: 9 self._implicit_app_ctx_stack.append(None) 10 11 if hasattr(sys, 'exc_clear'): 12 sys.exc_clear() 13 14 _request_ctx_stack.push(self) 15 16 if self.session is None: 17 session_interface = self.app.session_interface 18 self.session = session_interface.open_session( 19 self.app, self.request 20 ) 21 22 if self.session is None: 23 self.session = session_interface.make_null_session(self.app)
3.4 上下文总结
Flask的上下文由请求上下文RequestContext类实例和程序上下文AppContext实例
请求上下文对象存储在请求上下文堆栈（_request_ctx_stack）
程序上下文对象存储在程序上下文堆栈（_app_ctx_stack）
每个请求都会创建新的请求上下文栈，同时会创建新的程序上下文栈
全局变量request，session保存在RequestContext实例中
全局变量current_app，g保存存在AppContext
4、总结
Flask实际上就是通过代码，将主要的处理请求的库werkzeug和模板库jinja2组合起来
通过上下文使用户可以在程序中方便的使用全局变量request、session等等，并解决了多线程线程安全的问题
小而精，其他的功能都可以通过各种三方库来扩展、