Flask - 上下文管理(核心)
参考
- http://flask.pocoo.org/docs/1.0/advanced_foreword/#thread-locals-in-flask
- https://zhuanlan.zhihu.com/p/33732859
- https://www.zhihu.com/question/25033592/answer/34449852
- https://www.zhihu.com/question/269905592/answer/364928400
- http://flask.pocoo.org/docs/1.0/appcontext/#purpose-of-the-context
- http://flask.pocoo.org/docs/1.0/reqcontext/
- http://flask.pocoo.org/docs/1.0/appcontext/#storing-data
其实看5和6,7就够了,因为是权威的文档
Flask的上下文管理很重要,留坑
1-5为预备知识,从6正式开始
现象:
Flask 从客户端收到请求时,要让视图函数能访问一些对象,这样才能处理请求。请求对象就是一个很好的例子,它封装了客户端发送的HTTP 请求。要想让视图函数能够访问请求对象,一个显而易见的方式是将其作为参数传入视图函数,不过这会导致程序中的每个视图函数都增加一个参数。除了访问请求对象,如果视图函数在处理请求时还要访问其他对象,情况会变得更糟。为了避免大量可有可无的参数把视图函数弄得一团糟,Flask 使用上下文临时把某些对象变为全局可访问。
PS: 访问其他对象,例如请求对象
django/tornado是通过传参数形式,Flask是通过上下文管理。
问题:flask的request和session设置方式比较新颖,如果没有这种方式,那么就只能通过参数的传递。flask是如何做的呢?
虽然threading.local与这个实现没关系,不过要先了解threading.local对象才能理解Flask的上下文管
1. threading.local对象,用于为每个线程开辟一块空间来保存它独有的值。
Flask的上下文管理借助了这个思想。Thread-local data is data whose values are thread specific
本地线程,保证即使是多个线程,自己的值也是互相隔离。
import threading
# class Foo(object):
# def __init__(self):
# self.name = 0
#
# local_values = Foo()
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()
如果不用threading.local(),那么
因为修改的值始终保存在同一个对象里面,sleep一秒后,全部线程执行完毕,值变成了最后的值19。
2. 单进程单线程多协程中,threading.local会出问题,因为协程数据都存在同一个线程里。
解决方法为:
单进程单线程多协程中,程序不再支持协程,就可以使用threading.local对象。
单进程单线程多协程中,程序想支持协程,那么自定义类似threading.local对象。如下所示
> 自定义类似threading.local对象,支持协程(Python中greenlet就是协程),原理是一个标识identification对应一个字典(存储数据的地方)
"""
{
identification:{k:v},一个标识对应一个字典,threading.local工作原理类似这样,看源码可知,
class _localimpl:
"""A class managing thread-local dicts"""
}
"""
import threading
try:
#获取标识identification
from greenlet import getcurrent as get_ident # 协程
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident # 线程
# 模拟threading.Local()且支持协程
class Local(object):
def __init__(self):
self.storage = {}
self.get_ident = get_ident
def set(self,k,v):
ident = self.get_ident()
origin = self.storage.get(ident)
if not origin:
origin = {k:v}
else:
origin[k] = v
self.storage[ident] = origin
def get(self,k):
ident = self.get_ident()
origin = self.storage.get(ident)
if not origin:
return None
return origin.get(k,None)
local_values = Local()
def task(num):
local_values.set('name',num)
import time
time.sleep(1)
print(local_values.get('name'), threading.current_thread().name)
for i in range(20):
th = threading.Thread(target=task, args=(i,),name='线程%s' % i)
th.start()
3. 注意__setattr__的坑,为往后的点作铺垫.
http://www.cnblogs.com/allen2333/p/9019660.html
改正后,可以用__setattr__,getattr
import threading
try:
from greenlet import getcurrent as get_ident # 协程
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident # 线程
class Local(object):
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__
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)
local_values = Local()
def task(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=task, args=(i,),name='线程%s' % i)
th.start()
4. 上下文原理
#!/usr/bin/env python
# -*- 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)
5. Flask内部实现
#!/usr/bin/env python
# -*- 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)
6. 大概流程(重要,去看源码理解)
6.1 借鉴threading.Local(线程临时存对象的地方),Flask自定义Local对象(Local, LocalStack, LocalProxy)。Local类似threading.Local,是临时存对象的地方,比后者多出协程支持。
上下文管理:
类似threading.local ,Flask自己实现 Local类(临时存对象的地方),其中创建了一个字典,{用greenlet协程做唯一标识:存数据} 保证数据隔离
请求进来时:
- 请求相关所有数据封装到了RequestContext中。ctx = 封装RequestContext(request,session)
- 再将ctx = RequestContext对象添加到Local中(通过LocalStack将对象添加到Local对象中)
执行view function时,调用request:
-调用此类方法: request.method、print(request)、request + xxx。
from flask import request中查看request源码
_request_ctx_stack = LocalStack()
request = LocalProxy(partial(_lookup_req_object, 'request'))
- request.method会执行LocalProxy中对应的方法(getattr) --> 对应的方法执行_get_current_object --> 偏函数(._lookup_req_object(), request)--> 通过LocalStack从Local中 --> 获取top = RequestContext --> ctx.request --> getattr --> ctx.request.method
请求终止时:- ctx.auto_pop()
- 通过LocalStack的pop方法,ctx从Local对象中移除。
session
- 过程一样,只是最后是ctx.session,相比较于ctx.request
7. 应用上下文和请求上下文什么关系?
from flask import Flask, request, g, globals
app = Flask('_name_'), app._call_, ctx.push()
在这两段代码进去看源码
globals.py
_request_ctx_stack = LocalStack()
_app_ctx_stack = LocalStack()
在app.__call__进去,ctx = self.request_context(environ),再从ctx.push()进去
top = _request_ctx_stack.top
...
top = _request_ctx_stack.top
if top is not None and top.preserved:
top.pop(top._preserved_exc)
# Before we push the request context we have to ensure that there
# is an application context.
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()
self._implicit_app_ctx_stack.append(app_ctx)
else:
self._implicit_app_ctx_stack.append(None)
if hasattr(sys, 'exc_clear'):
sys.exc_clear()
_request_ctx_stack.push(self)
所以应用上下文在每个请求上下文被push到__request_ctx_stack之前,自己被push到_app_ctx_stack中
8. request和g的区别
g,每个请求周期都会创建一个用于在请求周期中传递值的一个容器。
request(在请求上下文中,LocalStack -- > 存储在Local中)和g都是临时容器,用来存储stuff。但是在程序中为了不修改request(封装了请求的参数),所以用g(在应用上下文中初始化,LocalStack -- >存储在Local中)来代替request存储数据、对象。
_request_ctx_stack = LocalStack(),_app_ctx_stack = LocalStack(),两个是不同的LocalStack --> 不同的Local。PS:Local是临时存储stuff的地方。
from flask import Flask, request, g, globals
app = Flask('name'), app.call, ctx.push()
在这两段代码进去看源码
_request_ctx_stack.Local() = {
唯一标识ident: {
"stack":[request_ctx, ]
}
}
_app_ctx_stack.Local() = {
唯一标识ident: {
"stack":[app_ctx, ]
}
}
request_ctx = RequestContext(),app_ctx = AppContext()
9. from flask import request,session,g,current_app
参考6,print(request,session,g,current_app),都会执行相应LocalProxy对象的 str,也就是都是从LocalProxy出发
唯一不同的是传递的偏函数的参数不一样
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
current_app = LocalProxy(_find_app)
g = LocalProxy(partial(_lookup_app_object, 'g'))
10. 一个程序多线程有多少个Local? Web访问多app应用时,上下文管理是如何实现?
还是原来的流程,wsgi --> push到Local。都是只有两个Local,通过唯一标识存储context.
_request_ctx_stack.Local() = {
唯一标识ident: {
"stack":[request_ctx, ]
}
唯一标识ident: {
"stack":[request_ctx, ]
}
....
}
_app_ctx_stack.Local() = {
唯一标识ident: {
"stack":[app_ctx, ]
}
唯一标识ident: {
"stack":[app_ctx, ]
}
}
11. Flask的Local中保存数据时,使用列表创建出来的栈。为什么用栈?
"stack":[app_ctx, ]
如果写web程序,web运行环境;栈中永远保存1条数据(可以不用栈)。
写脚本获取app信息时,可能存在app上下文嵌套关系,栈可能有多条数据。
意味着栈是备用的!
例如写测试脚本时,获取app1, app2的信息,测试一下数据库是否正确连接
总结来说,为了部落!(多应用)
from flask import Flask, current_app, globals, _app_ctx_stack
app1 = Flask('app01')
app1.debug = False # 用户/密码/邮箱
# app_ctx = AppContext(self):
# app_ctx.app
# app_ctx.g
#RuntimeError: Working outside of application context.
#print(current_app.config['DEBUG'])
app2 = Flask('app02')
app2.debug = True # 用户/密码/邮箱
# app_ctx = AppContext(self):
# app_ctx.app
# app_ctx.g
# 写脚本的时候有上下文嵌套的写法。但是写网站的时候没可能有两个或以上app嵌套,堆栈里的stack永远放的是一个。"stack":[app_ctx, ]
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)
print(current_app.config['DEBUG'])
# 写在里面,Local:{'stack' : [ctx1, ctx2]}有两个了!stack.top --> stack[-1] --> 还是拿栈顶的!
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)
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)
print(current_app.config['DEBUG'])
"""