flask的request和session设置方式比较新颖，如果没有这种方式，那么就只能通过参数的传递。
flask是如何做的呢？
1：本地线程，保证即使是多个线程，自己的值也是互相隔离
1 import threading 2 3 local_values = threading.local() 4 5 6 def func(num): 7 local_values.name = num 8 import time 9 time.sleep(1) 10 print(local_values.name, threading.current_thread().name) 11 12 13 for i in range(20): 14 th = threading.Thread(target=func, args=(i,), name='线程%s' % i) 15 th.start()
2：自定义threading.local
1 """ 2 { 3 1368:{} 4 } 5 6 7 8 """ 9 import threading 10 try: 11 from greenlet import getcurrent as get_ident # 协程 12 except ImportError: 13 try: 14 from thread import get_ident 15 except ImportError: 16 from _thread import get_ident # 线程 17 18 19 class Local(object): 20 def __init__(self): 21 self.storage = {} 22 self.get_ident = get_ident 23 24 def set(self,k,v): 25 ident = self.get_ident() 26 origin = self.storage.get(ident) 27 if not origin: 28 origin = {k:v} 29 else: 30 origin[k] = v 31 self.storage[ident] = origin 32 33 def get(self,k): 34 ident = self.get_ident() 35 origin = self.storage.get(ident) 36 if not origin: 37 return None 38 return origin.get(k,None) 39 40 local_values = Local() 41 42 43 def task(num): 44 local_values.set('name',num) 45 import time 46 time.sleep(1) 47 print(local_values.get('name'), threading.current_thread().name) 48 49 50 for i in range(20): 51 th = threading.Thread(target=task, args=(i,),name='线程%s' % i) 52 th.start()
升级版
1 import threading 2 try: 3 from greenlet import getcurrent as get_ident # 协程 4 except ImportError: 5 try: 6 from thread import get_ident 7 except ImportError: 8 from _thread import get_ident # 线程 9 10 11 class Local(object): 12 13 def __init__(self): 14 object.__setattr__(self, '__storage__', {}) 15 object.__setattr__(self, '__ident_func__', get_ident) 16 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) 37 38 39 local_values = Local() 40 41 42 def task(num): 43 local_values.name = num 44 import time 45 time.sleep(1) 46 print(local_values.name, threading.current_thread().name) 47 48 49 for i in range(20): 50 th = threading.Thread(target=task, args=(i,),name='线程%s' % i) 51 th.start()
说明解释：
1 - threading.local对象，用于为每个线程开辟一块空间来保存它独有的值。 2 3 - 源码（request） 4 - 情况一：单进程单线程，基于全局变量做。 5 - 情况二：单进程多线程，threading.local对象。 6 - 情况二：单进程单线程（多个协程），threading.local对象做不到。 7 8 - 决定： 9 - 以后不支持协程：threading.local对象。 10 - 支持：自定义类似threading.local对象（支持协程） 11 - 自定义类似threading.local对象 12 PS: 13 a. 14 object.__setattr__(self, 'storage', {}) 15 self.storage = {} 16 b. 17 对象.xx 18 def __setattr__(self, key, value): 19 print(key,value)
3：请求上下文原理
1 from functools import partial 2 from flask.globals import LocalStack, LocalProxy 3 4 ls = LocalStack() 5 6 7 class RequestContext(object): 8 def __init__(self, environ): 9 self.request = environ 10 11 12 def _lookup_req_object(name): 13 top = ls.top 14 if top is None: 15 raise RuntimeError(ls) 16 return getattr(top, name) 17 18 19 session = LocalProxy(partial(_lookup_req_object, 'request')) 20 21 ls.push(RequestContext('c1')) # 当请求进来时，放入 22 print(session) # 视图函数使用 23 print(session) # 视图函数使用 24 ls.pop() # 请求结束pop 25 26 27 ls.push(RequestContext('c2')) 28 print(session) 29 30 ls.push(RequestContext('c3')) 31 print(session)
4：请求上下文源码
1 from greenlet import getcurrent as get_ident 2 3 4 def release_local(local): 5 local.__release_local__() 6 7 8 class Local(object): 9 __slots__ = ('__storage__', '__ident_func__') 10 11 def __init__(self): 12 # self.__storage__ = {} 13 # self.__ident_func__ = get_ident 14 object.__setattr__(self, '__storage__', {}) 15 object.__setattr__(self, '__ident_func__', get_ident) 16 17 def __release_local__(self): 18 self.__storage__.pop(self.__ident_func__(), None) 19 20 def __getattr__(self, name): 21 try: 22 return self.__storage__[self.__ident_func__()][name] 23 except KeyError: 24 raise AttributeError(name) 25 26 def __setattr__(self, name, value): 27 ident = self.__ident_func__() 28 storage = self.__storage__ 29 try: 30 storage[ident][name] = value 31 except KeyError: 32 storage[ident] = {name: value} 33 34 def __delattr__(self, name): 35 try: 36 del self.__storage__[self.__ident_func__()][name] 37 except KeyError: 38 raise AttributeError(name) 39 40 41 class LocalStack(object): 42 def __init__(self): 43 self._local = Local() 44 45 def __release_local__(self): 46 self._local.__release_local__() 47 48 def push(self, obj): 49 """Pushes a new item to the stack""" 50 rv = getattr(self._local, 'stack', None) 51 if rv is None: 52 self._local.stack = rv = [] 53 rv.append(obj) 54 return rv 55 56 def pop(self): 57 """Removes the topmost item from the stack, will return the 58 old value or `None` if the stack was already empty. 59 """ 60 stack = getattr(self._local, 'stack', None) 61 if stack is None: 62 return None 63 elif len(stack) == 1: 64 release_local(self._local) 65 return stack[-1] 66 else: 67 return stack.pop() 68 69 @property 70 def top(self): 71 """The topmost item on the stack. If the stack is empty, 72 `None` is returned. 73 """ 74 try: 75 return self._local.stack[-1] 76 except (AttributeError, IndexError): 77 return None 78 79 80 stc = LocalStack() 81 82 stc.push(123) 83 v = stc.pop() 84 85 print(v)
5：个人源码剖析
a.偏函数
1 import functools 2 3 def func(a1): 4 print(a1) 5 6 7 new_func = functools.partial(func,666) 8 9 new_func() 10 11 说明：将666这个参数当做func函数的第一个参数
b.第一阶段
1 1.当携带这用户的请求过来之后，首先会执行app.run，会执行 run_simple(host, port, self, **options)，因为run方法是由app调用的，app又是Flask的对象，因此当执行了app.run()之后就会调用Flask类中的__call__方法 2 2.进入app.__call__拿到return self.wsgi_app(environ, start_response) 3 3.进入app.wsgi_app之后就会执行：ctx = self.request_context(environ) 4 app.request_context(environ)会返回 return RequestContext(self, environ)；然后执行__init__方法得到request = app.request_class(environ)；最后将请求的信息放入request中。经过上面的操作，得出ctx就是携带有请求信息的request_context对象，ctx里面具有ctx.app,ctx.request,ctx.session 5 4.然后执行ctx.push() 6 进入push()里面找到 _request_ctx_stack.push(self)，这里面的self指的是ctx对象，_request_ctx_stack是全局变量，_request_ctx_stack = LocalStack()，_request_ctx_stack 是LocalStack这个类的对象；通过def push(self, obj)这个方法将ctx这个对象存入threadinglocal中，给ctx这个对象分配专属与他的一块内存空间。
c.第二阶段
1 如果需要打印print(request),源码是如何执行的呢？ 2 进入request 3 1.request = LocalProxy(partial(_lookup_req_object, 'request')) 4 这个里面：偏函数=partial(_lookup_req_object, 'request') 5 首先执行LocalProxy这个类实例化执行__init__方法： 6 def __init__(self, local, name=None): 7 object.__setattr__(self, '_LocalProxy__local', local) 8 在这里：_LocalProxy__local其实就是强制获取私有字段等价于 9 self._local = local 10 2.再执行__str__方法： 11 __str__ = lambda x: str(x._get_current_object()) 12 3.def _get_current_object(self): 13 if not hasattr(self.__local, '__release_local__'): 14 return self.__local() 15 try: 16 return getattr(self.__local, self.__name__) 17 返回return self.__local()，执行偏函数 18 def _lookup_req_object(name): 19 top = _request_ctx_stack.top 20 if top is None: 21 raise RuntimeError(_request_ctx_err_msg) 22 return getattr(top, name) 23 4.从top = _request_ctx_stack.top中去拿开始存入的ctx对象，然后再从ctx对象中去拿request： return self._local.stack[-1] 24 5.通过getattr(top, name)==getattr(ctx对象，request) 25 26 如果是打印print(request.method) 27 其实就是多了一步，再执行__str__方法之前执行def __getattr__(self, name)方法 28 29 30 代码示例展示： 31 from flask import Flask,request,session,g,current_app 32 33 app = Flask(__name__) 34 35 @app.route('/',methods=['GET',"POST"]) 36 def index(): 37 # request是 LocalProxy 的对象 38 print(request) # LocalProxy.__str__ --> str(LocalProxy._get_current_object) --> 调用偏函数 --> ctx.request 39 request.method # LocalProxy.__getattr__ --> 40 # str(LocalProxy._get_current_object) --> 调用偏函数 --> ctx.request 41 # getattr(self._get_current_object(), name) --> ctx.request.method 42 43 request.path # ctx.request.path 44 45 print(session) # LocalProxy.__str__ --> str(LocalProxy._get_current_object) --> 调用偏函数 --> ctx.session 46 47 48 print(g) # 执行g对象的__str__ 49 return "index" 50 51 52 if __name__ == '__main__': 53 app.__call__ 54 app.wsgi_app 55 app.wsgi_app 56 app.request_class 57 app.run()
d.第三阶段
1 # 寻找视图函数并执行，获取返回值 2 response = self.full_dispatch_request() 3 4 1.先执行before_first_request 5 self.try_trigger_before_first_request_functions() 6 7 2.触发request_started信号，request_started 8 request_started.send(self) 9 补充：信号： 10 from flask import Flask, signals, render_template 11 12 app = Flask(__name__) 13 14 15 # 往信号中注册函数 16 def func(*args, **kwargs): 17 print('触发型号', args, kwargs) 18 19 20 signals.request_started.connect(func) 21 22 23 # 触发信号： signals.request_started.send() 24 25 @app.before_first_request 26 def before_first1(*args, **kwargs): 27 pass 28 29 30 @app.before_first_request 31 def before_first2(*args, **kwargs): 32 pass 33 34 35 @app.before_request 36 def before_first3(*args, **kwargs): 37 pass 38 39 40 @app.route('/', methods=['GET', "POST"]) 41 def index(): 42 print('视图') 43 return render_template('index.html') 44 45 46 if __name__ == '__main__': 47 app.wsgi_app 48 app.run() 49 50 3.再执行def preprocess_request(self):中的before_request 51 52 4.# 执行视图函数dispatch_request-->def render_template(template_name_or_list, **context):-->before_render_template.send(app, template=template, context=context)-->template_rendered.send(app, template=template, context=context) 53 rv = self.dispatch_request() 54 55 5. 执行self.finalize_request(rv)--> response = self.process_response(response)-->self.session_interface.save_session(self, ctx.session, response) 56 57 6.执行after_request 58 59 7.执行信号request_finished.send(self, response=response)
e.第四阶段
1 ctx.auto_pop,将请求信息从threadinglocal中清除 2 1.ctx.auto_pop -->self.pop(exc)-->_request_ctx_stack.pop() 3 4 2._request_ctx_stack = LocalStack()-->return stack.pop()
6.应用上下文原理(跟请求上下文的原理几乎一致)
1 通过app_ctx.push()将app_ctx对象存储到threadinglocal中，分配一块独有的内存空间，app_ctx对象中具有：app_ctx.app与app_ctx.g 2 3 1.app_ctx.g是存储变量用的 4 示例代码： 5 from flask import Flask,request,g 6 7 app = Flask(__name__) 8 9 @app.before_request 10 def before(): 11 g.permission_code_list = ['list','add'] 12 13 14 @app.route('/',methods=['GET',"POST"]) 15 def index(): 16 print(g.permission_code_list) 17 return "index" 18 19 20 if __name__ == '__main__': 21 app.run()
补充：
a：离线脚本示例
1 """ 2 需求：不用数据库连接池，显示数据库连接 3 """ 4 class SQLHelper(object): 5 6 def open(self): 7 pass 8 9 def fetch(self,sql): 10 pass 11 12 def close(self): 13 pass 14 15 def __enter__(self): 16 self.open() 17 return self 18 19 def __exit__(self, exc_type, exc_val, exc_tb): 20 self.close() 21 22 23 # obj = SQLHelper() 24 # obj.open() 25 # obj.fetch('select ....') 26 # obj.close() 27 28 29 with SQLHelper() as obj: # 自动调用类中的__enter__方法, obj就是__enter__返回值 30 obj.fetch('xxxx') 31 # 当执行完毕后，自动调用类 __exit__ 方法
1 from flask import Flask,current_app,globals,_app_ctx_stack 2 3 app1 = Flask('app01') 4 app1.debug = False # 用户/密码/邮箱 5 # app_ctx = AppContext(self): 6 # app_ctx.app 7 # app_ctx.g 8 9 app2 = Flask('app02') 10 app2.debug = True # 用户/密码/邮箱 11 # app_ctx = AppContext(self): 12 # app_ctx.app 13 # app_ctx.g 14 15 16 17 with app1.app_context():# __enter__方法 -> push -> app_ctx添加到_app_ctx_stack.local 18 # {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438>]}} 19 print(_app_ctx_stack._local.__storage__) 20 print(current_app.config['DEBUG']) 21 22 with app2.app_context(): 23 # {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438> ]}} 24 print(_app_ctx_stack._local.__storage__) 25 print(current_app.config['DEBUG']) 26 27 print(current_app.config['DEBUG'])
7.总结
1 1. 面向对象私有 2 class Foo(object): 3 4 def __init__(self): 5 self.name = 'alex' 6 self.__age = 18 7 8 def get_age(self): 9 return self.__age 10 11 obj = Foo() 12 # print(obj.name) 13 # print(obj.get_age()) 14 # 强制获取私有字段 15 print(obj._Foo__age) 16 17 2. 谈谈Flask上下文管理 18 - 与django相比是两种不同的实现方式。 19 - django/tornado是通过传参数形式 20 - flask是通过上下文管理 21 两种都可以实现，只不过试下方式不一样。 22 - 上下文管理： 23 - threading.local/Local类，其中创建了一个字典{greelet做唯一标识：存数据} 保证数据隔离 24 - 请求进来： 25 - 请求相关所有数据封装到了RequestContext中。 26 - 再讲RequestContext对象添加到Local中（通过LocalStack将对象添加到Local对象中） 27 - 使用，调用request 28 - 调用此类方法 request.method、print(request)、request+xxx 会执行LocalProxy中对应的方法 29 - 函数 30 - 通过LocalStack去Local中获取值。 31 - 请求终止 32 - 通过LocalStack的pop方法 Local中将值异常。 33 34 3.上下文 35 a. 请求上下文 36 - request 37 - session 38 b. 应用上下文 39 40 41 请求流程： 42 _request_ctx_stack.local = { 43 44 } 45 46 _app_ctx_stack.local = { 47 48 } 49 50 51 3.1. 请求到来 ，有人来访问 52 # 将请求相关的数据environ封装到了RequestContext对象中 53 # 再讲对象封装到local中（每个线程/每个协程独立空间存储） 54 # ctx.app # 当前APP的名称 55 # ctx.request # Request对象(封装请求相关东西) 56 # ctx.session # 空 57 _request_ctx_stack.local = { 58 唯一标识：{ 59 "stack":[ctx, ] 60 }, 61 唯一标识：{ 62 "stack":[ctx, ] 63 }, 64 } 65 66 67 # app_ctx = AppContext对象 68 # app_ctx.app 69 # app_ctx.g 70 71 _app_ctx_stack.local = { 72 唯一标识：{ 73 "stack":[app_ctx, ] 74 }, 75 唯一标识：{ 76 "stack":[app_ctx, ] 77 }, 78 } 79 80 3.2. 使用 81 from flask import request,session,g,current_app 82 83 print(request,session,g,current_app) 84 85 都会执行相应LocalProxy对象的 __str__ 86 87 current_app = LocalProxy(_find_app) 88 request = LocalProxy(partial(_lookup_req_object, 'request')) 89 session = LocalProxy(partial(_lookup_req_object, 'session')) 90 91 current_app = LocalProxy(_find_app) 92 g = LocalProxy(partial(_lookup_app_object, 'g')) 93 94 3.3. 终止，全部pop 95 96 问题1：多线程是如何体现？ 97 问题2：flask的local中保存数据时，使用列表创建出来的栈。为什么用栈？ 98 - 如果写web程序，web运行环境；栈中永远保存1条数据（可以不用栈）。 99 - 写脚本获取app信息时，可能存在app上下文嵌套关系。 100 from flask import Flask,current_app,globals,_app_ctx_stack 101 102 app1 = Flask('app01') 103 app1.debug = False # 用户/密码/邮箱 104 # app_ctx = AppContext(self): 105 # app_ctx.app 106 # app_ctx.g 107 108 app2 = Flask('app02') 109 app2.debug = True # 用户/密码/邮箱 110 # app_ctx = AppContext(self): 111 # app_ctx.app 112 # app_ctx.g 113 114 115 116 with app1.app_context():# __enter__方法 -> push -> app_ctx添加到_app_ctx_stack.local 117 # {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438>]}} 118 print(_app_ctx_stack._local.__storage__) 119 print(current_app.config['DEBUG']) 120 121 with app2.app_context(): 122 # {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438> ]}} 123 print(_app_ctx_stack._local.__storage__) 124 print(current_app.config['DEBUG']) 125 126 print(current_app.config['DEBUG']) 127 128 3.3. 多app应用 129 130 from werkzeug.wsgi import DispatcherMiddleware 131 from werkzeug.serving import run_simple 132 from flask import Flask, current_app 133 134 app1 = Flask('app01') 135 136 app2 = Flask('app02') 137 138 139 140 @app1.route('/index') 141 def index(): 142 return "app01" 143 144 145 @app2.route('/index2') 146 def index2(): 147 return "app2" 148 149 # http://www.oldboyedu.com/index 150 # http://www.oldboyedu.com/sec/index2 151 dm = DispatcherMiddleware(app1, { 152 '/sec': app2, 153 }) 154 155 if __name__ == "__main__": 156 run_simple('localhost', 5000, dm) 157 158 4.信号 159 a. before_first_request 160 b. 触发 request_started 信号 161 c. before_request 162 d. 模板渲染 163 渲染前的信号 before_render_template.send(app, template=template, context=context) 164 rv = template.render(context) # 模板渲染 165 渲染后的信号 template_rendered.send(app, template=template, context=context) 166 e. after_request 167 f. session.save_session() 168 g. 触发 request_finished信号 169 170 如果上述过程出错： 171 触发错误处理信号 got_request_exception.send(self, exception=e) 172 173 h. 触发信号 request_tearing_down 174 175 5.面向对象 176 - 封装 177 class Foo: 178 def __init__(self): 179 self.age = 123 180 self.nmame = 'ssdf' 181 182 class Bar: 183 def __init__(self): 184 self.xx = 111 185 186 187 188 class Base: 189 def __init__(self): 190 self.f = Foo() 191 self.x = Bar() 192 - 某个值+括号 193 - 函数/方法 194 - 类 195 - 对象 196 197 - 特殊的双下划线方法： 198 __new__ 199 __call__ 200 __str__ 201 __setattr__ 202 __setitem__ 203 __enter__ 204 __exit__ 205 __add__ 206 207 PS: Flask的LocalProxy中全部使用。 208 209 - 强制调用私有字段 210 - 派生类中无法调用基类私有字段