Flask运行原理

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等等，并解决了多线程线程安全的问题

小而精，其他的功能都可以通过各种三方库来扩展、