先看一个例子： #!/usr/bin/env python # -*- coding:utf-8 -*- import threading # local_values = threading.local() class Foo(object): def __init__(self): self.name = 0 local_values = Foo() def func(num): local_values.name = num import t
先看一个例子：
#!/usr/bin/env python# -*- coding:utf-8 -*-
import threading
# local_values = threading.local()
class Foo(object):
def __init__(self):
self.name = 0
local_values = Foo()
def func(num):
local_values.name = num
import time
time.sleep(1)
print(local_values.name,threading.current_thread().name)
for i in range(5):
th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
th.start()4 线程0
4 线程1
4 线程3
4 线程2
4 线程4
上述结果不是我们想要的，local_values.name的值被最后一个覆盖了.............................
flask的request和session设置方式比较新颖，如果没有这种方式，那么就只能通过参数的传递。
flask是如何做的呢？
1. 本地线程，保证即使是多个线程，自己的值也是互相隔离。
#!/usr/bin/env python# -*- coding:utf-8 -*-
import threading
local_values = threading.local()
def func(num):
local_values.name = num
import time
time.sleep(1)
print(local_values.name, threading.current_thread().name)
for i in range(20):
th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
th.start()
import threading
def task(num):
print(get_ident())
for i in range(10):
th = threading.Thread(target=task,args=(i,),name='线程%s' % i)
th.start()
View Code
如上图所示，每个线程都有一个唯一标识
def __init__(self):
pass
def __setattr__(self, key, value):
print(key,value)
def __getattr__(self, item):
print(item)
obj = Foo()
obj.xxx=123
obj.xxx
__setattr__ __getattr__
自定义Local
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 #递归执行__setattr__
15 # self.__storage__={}
16 # self.__ident_func__=get_ident
17 object.__setattr__(self, '__storage__', {})
18 object.__setattr__(self, '__ident_func__', get_ident)
19
20
21 def __getattr__(self, name):
22 try:
23 return self.__storage__[self.__ident_func__()][name]
24 except KeyError:
25 raise AttributeError(name)
26
27 def __setattr__(self, name, value):
28 ident = self.__ident_func__()
29 storage = self.__storage__
30 try:
31 storage[ident][name] = value
32 except KeyError:
33 storage[ident] = {name: value}
34
35 def __delattr__(self, name):
36 try:
37 del self.__storage__[self.__ident_func__()][name]
38 except KeyError:
39 raise AttributeError(name)
40
41
42 local_values = Local()
43
44
45 def task(num):
46 local_values.name = num
47 import time
48 time.sleep(1)
49 print(local_values.name, threading.current_thread().name)
50
51
52 for i in range(5):
53 th = threading.Thread(target=task, args=(i,),name='线程%s' % i)
54 th.start()
55
56
57
58 执行结果：
59 0 线程0
60 1 线程1
61 2 线程2
62 4 线程4
63 3 线程3
View Code
2. 上下文原理
# -*- coding:utf-8 -*-
from functools import partial
from flask.globals import LocalStack, LocalProxy
ls = LocalStack()
class RequestContext(object):
def __init__(self, environ):
self.request = environ
def _lookup_req_object(name):
top = ls.top
if top is None:
raise RuntimeError(ls)
return getattr(top, name)
session = LocalProxy(partial(_lookup_req_object, 'request'))
ls.push(RequestContext('c1')) # 当请求进来时，放入
print(session) # 视图函数使用
print(session) # 视图函数使用
ls.pop() # 请求结束pop
ls.push(RequestContext('c2'))
print(session)
ls.push(RequestContext('c3'))
print(session)
View Code
3. Flask内部实现
# -*- coding:utf-8 -*-
from greenlet import getcurrent as get_ident
def release_local(local):
local.__release_local__()
class Local(object):
__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
# self.__storage__ = {}
# self.__ident_func__ = get_ident
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
def __release_local__(self):
self.__storage__.pop(self.__ident_func__(), None)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
def __delattr__(self, name):
try:
del self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
class LocalStack(object):
def __init__(self):
self._local = Local()
def __release_local__(self):
self._local.__release_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
def pop(self):
"""Removes the topmost item from the stack, will return the
old value or `None` if the stack was already empty.
"""
stack = getattr(self._local, 'stack', None)
if stack is None:
return None
elif len(stack) == 1:
release_local(self._local)
return stack[-1]
else:
return stack.pop()
@property
def top(self):
"""The topmost item on the stack. If the stack is empty,
`None` is returned.
"""
try:
return self._local.stack[-1]
except (AttributeError, IndexError):
return None
stc = LocalStack()
stc.push(123)
v = stc.pop()
print(v)
View Code
------------------------------------------源码分析（重点）：----------------------------------------------------------------------
首先看这段代码：
if __name__ == '__main__':# 1.1
app.__call__
app.request_class
response_class = Response
app.run()
在上面提到了上下文的原理：
-----------------------LocalStak-----------------Local-----------------------------------
globals.py中有这么段代码，定义了request
# \flask\globals.py# context locals
# 全局变量
_request_ctx_stack = LocalStack()
# _app_ctx_stack = LocalStack()
# current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
# g = LocalProxy(partial(_lookup_app_object, 'g'))
# Local类
class Local(object):__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
"""
{
唯一标识（__ident_func__）：{
stack:[ctx/requestcontext,]//栈
}
}
"""
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
# LocalStack类
def __init__(self):self._local = Local()
# LocalStack()就是我们之前写过的一个多线程数据相互隔离的类，每个线程都有一个唯一标识
# 每个线程都有一个独立的存储数据和访问数据的空间
# __storage__ __ident_func__
# \werkzeug\local.py
# Local类 每个线程唯一标识 可以存储数据
# LocalStack类 实例化Local类
# LocalStack类
def push(self, obj):
# 刚开始stack=[]
rv = getattr(self._local, 'stack', None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)//执行Local的__setattr__方法
return rv
def pop(self):
stack = getattr(self._local, 'stack', None)
if stack is None:
return None
elif len(stack) == 1:
release_local(self._local)
return stack[-1]
else:
return stack.pop()
以上都是启动会加载的文件 ，创建唯一标识，并给这个标识赋值 stack=[],stack是个栈，存储着每个用户请求的对象（数据）RequestContext对象(ctx)
{唯一标识（__ident_func__）：{
stack:[ctx/requestcontext,]//栈
}
}
--------------------------------接下来开始看看执行流程：---------(app)-----------------------------------------------
app.__call__
app.request_class
response_class = Response
app.run()
执行app.__call__方法
app.run() =》run_simple(host, port, self, **options) =》app.__call__
# \flask\app.py
# 主要从这里入手 分析代码
# Flask类（app）
app.py
def __call__(self, environ, start_response):return self.wsgi_app(environ, start_response)
app.py
def wsgi_app(self, environ, start_response):#将请求相关的数据environ封装到了RequestContext对象中
#再将对象封装到Local中（每个线程/每个协程独立空间存储）
#request_context对象中有如下：
#ctx.app 当前APP
#ctx.request Request对象（封装请求相关的东西）
#ctx.session
#RequestContext类 ctx.py
ctx = self.request_context(environ)
error = None
try:
try:
#RequestContext.push()->LocalStack.push
#将封装了请求相关的RequestContext对象中的对象添加到LocalStack.push(self)
#_request_ctx_stack = LocalStack()
"""
{
唯一标识（__ident_func__）：{
stack:[ctx/requestcontext,]//栈
}
}
"""
# 将ctx通过LocalStack添加到Local中
# 此时ctx中的session中已经有值了
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
#RequestContext.pop()->LocalStack.pop(_request_ctx_stack.pop())
#_request_ctx_stack = LocalStack()
#最后将自己请求在Local中保存的数据清除
ctx.auto_pop(error)
ctx = self.request_context(environ) 记住了！！！
def request_context(self, environ):#self=app
return RequestContext(self, environ)
ctx就是request_context对象
#request_context对象中有如下属性：
#ctx.app 当前APP
#ctx.request Request对象（封装请求相关的东西）
#ctx.session
#执行RequestContext.push()->LocalStack.push
#将封装了请求相关的RequestContext对象中的对象添加到LocalStack.push(self)
"""
{
唯一标识（__ident_func__）：{
stack:[ctx/requestcontext,]//栈
}
}
"""
--------------------------RequestContext------------ctx.py-------------------------------------
# RequestContext类
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()
request = app.request_class(environ)
#ctx.push
def push(self):
top = _request_ctx_stack.top
if top is not None and top.preserved:
top.pop(top._preserved_exc)
app_ctx = _app_ctx_stack.top
if app_ctx is None or app_ctx.app != self.app:
# 应用上下文
# app_ctx = AppContext对象
# app_ctx.app = Flask对象
# app_ctx.g=对象（用于一个周期内要保存的值，相当于全局变量）
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()
#selft 是RequestContext对象 也是app里面的ctx，包含了请求所有数据
#_request_ctx_stack = LocalStack()
#相当于执行LocalStack.push()
#self 就是RequestContext类
_request_ctx_stack.push(）
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)
RequestContext对象中有request,session等对象，#ctx.push执行的就是RequestContext.push,其中有这么段代码
_request_ctx_stack.push(）#self 是RequestContext对象 也是app里面的ctx，包含了请求所有数据#_request_ctx_stack = LocalStack()
#相当于执行LocalStack.push()
#self 就是RequestContext类
_request_ctx_stack.push(）
组中执行的是Local中 storage[ident][name] =value
最终目的就是把RequestContext对象也就是ctx放到localStack中的唯一标识字典中的stack栈中
以上明白了吗？不明白可以去看看源码。。。。。 现在已经出现了
ctx=RequestContext app LocalStack Local 四个类
globals.py 刚开始启动加载的文件
到这里 请求上下文已经差不多了，每个请求都有一个独立数据存储空间，互补影响彼此。就是把request对象放到RequestContext.request属性里面，然后又把RequestContext对象放到每个线程（请求）或者是协程的一个唯一标识的stack栈中
"""
storage：{
唯一标识（__ident_func__）：{
stack:[ctx/requestcontext,]//栈
}
}
"""
视图中执行print(request)发生了什么？
--------------------------request-------------------------------------------------
# \flask\globals.py# 视图中执行print(request)发生了什么？
# 执行LocalProxy类中的__str__方法
# 在globals.py文件中 （最开始在加载的文件）
# context locals
_request_ctx_stack = LocalStack()
_app_ctx_stack = LocalStack()
current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
g = LocalProxy(partial(_lookup_app_object, 'g'))
# 偏函数做了啥？
#partial(_lookup_req_object, 'request')
# 函数_lookup_req_object 去LocalStack获取唯一标识栈里面的值（RequestContext对象）
def _lookup_req_object (name):
# _request_ctx_stack = LocalStack()
# 返回的其实就是刚开始塞到每个线程唯一标识里面的那个ctx/requestContext对象
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
# 到requestContext对象取request属性值 request对象
return getattr(top, name)
# LocalProxy类中的__str__方法 最终就是执行_lookup_req_object函数而已
__setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
在LocalStack类中：
@property
def top(self):
"""The topmost item on the stack. If the stack is empty,
`None` is returned.
"""
try:
return self._local.stack[-1]
except (AttributeError, IndexError):
return None
def _get_current_object(self):
if not hasattr(self.__local, '__release_local__'):
# 执行_lookup_req_object函数
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError('no object bound to %s' % self.__name__)
这段代码要仔细看看了
print(request) => LocalProxy。__str__ => LocalProxy.__str__ = lambda x: str(x._get_current_object()) =>（ _get_current_object 里面执行了 ）self.__local()
LocalProxy.__local 就是传入的偏函数（
partial(_lookup_req_object, 'request')）
最后执行self.__local() 相当于执行偏函数，返回request对象了
LocalProxy类中
def __init__(self, local, name=None):#Local = partial(_lookup_req_object, 'request')
#_local = _LocalProxy__local私有字段访问
object.__setattr__(self, '_LocalProxy__local', local)
object.__setattr__(self, '__name__', name)
if callable(local) and not hasattr(local, '__release_local__'):
object.__setattr__(self, '__wrapped__', local)
def _get_current_object(self):
if not hasattr(self.__local, '__release_local__'):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
_request_ctx_stack的应用
from flask.globals import _request_ctx_stack
from functools import partial
def _lookup_req_object(name):
# name = request
# top= ctx
top = _request_ctx_stack.top
if top is None:
raise RuntimeError('不存在')
# return ctx.request
return getattr(top, name)
class Foo(object):
def __init__(self):
self.xxx = 123
self.ooo = 888
req = partial(_lookup_req_object,'xxx')
xxx = partial(_lookup_req_object,'ooo')
# 当前求刚进来时
_request_ctx_stack.push(Foo())
# 使用
# obj = _request_ctx_stack.top
# obj.xxx
v1 = req()
print(v1)
v2 = xxx()
print(v2)
# 请求终止，将local中的值移除
_request_ctx_stack.pop()
_request_ctx_stack
上下文
- threading.Local和Flask自定义Local对象
- 请求到来
- ctx = 封装RequestContext(request,session)
- ctx放到Local中
- 执行视图时
- 导入request
- print(request) --> LocalProxy对象的__str__
- request.method --> LocalProxy对象的__getattr__
- request + 1 --> LocalProxy对象的__add__
- 调用 _lookup_req_object函数：去local中将requestContext想获取到，再去requestContext中获取request或session
- 请求结束
- ctx.auto_pop()
- ctx从local中移除。
多app应用
from werkzeug.serving import run_simple
from flask import Flask, current_app
app1 = Flask('app01')
app2 = Flask('app02')
@app1.route('/index')
def index():
return "app01"
@app2.route('/index2')
def index2():
return "app2"
# http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
dm = DispatcherMiddleware(app1, {
'/sec': app2,
})
if __name__ == "__main__":
app2.__call__
run_simple('localhost', 5000, dm)
View Code
离线脚本：
app1 = Flask('app01')
app1.debug = False # 用户/密码/邮箱
# app_ctx = AppContext(self):
# app_ctx.app
# app_ctx.g
app2 = Flask('app02')
app2.debug = True # 用户/密码/邮箱
# app_ctx = AppContext(self):
# app_ctx.app
# app_ctx.g
with app1.app_context():# __enter__方法 -> push -> app_ctx添加到_app_ctx_stack.local
# {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438>]}}
print(_app_ctx_stack._local.__storage__)
print(current_app.config['DEBUG'])
with app2.app_context():
# {<greenlet.greenlet object at 0x00000000036E2340>: {'stack': [<flask.ctx.AppContext object at 0x00000000037CA438> ]}}
print(_app_ctx_stack._local.__storage__)
print(current_app.config['DEBUG'])
print(current_app.config['DEBUG'])
View Code
需求：不用数据库连接池，显示数据库连接
"""
class SQLHelper(object):
def open(self):
pass
def fetch(self,sql):
pass
def close(self):
pass
def __enter__(self):
self.open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
# obj = SQLHelper()
# obj.open()
# obj.fetch('select ....')
# obj.close()
with SQLHelper() as obj: # 自动调用类中的__enter__方法, obj就是__enter__返回值
obj.fetch('xxxx')
# 当执行完毕后，自动调用类 __exit__ 方法
# 以后如果遇到：
View Code