详解Flask上下文
上下文是在Flask开发中的一个核心概念,本文将通过阅读源码分享下其原理和实现。
Flask系列文章:
- Flask开发初探
- WSGI到底是什么
- Flask源码分析一:服务启动
- Flask路由内部实现原理
- Flask容器化部署原理与实现
- Flask权限管理
首先,什么是Flask中的上下文?
在Flask中,对一个请求进行处理时,视图函数一般都会需要请求参数、配置等对象,当然不能对每个请求都传参一层层到视图函数(这显然很不优雅嘛),为此,设计出了上下文机制(比如像我们经常会调用的request就是上下文变量)。
Flask中提供了两种上下文:
- 请求上下文:包括request和session,保存请求相关的信息
- 程序上下文:包括current_app和g,为了更好的分离程序的状态,应用起来更加灵活,方便调测等
这四个是上下文变量具体的作用是什么?
- request:封装客户端发送的请求报文数据
- session:用于记住请求之间的数据,通过签名的cookie实现,常用来记住用户登录状态
- current_app:指向处理请求的当前程序实例,比如获取配置,经常会用current_app.config
- g:当前请求中的全局变量,因为程序上下文的生命周期是伴随请求上下文产生和销毁的,所以每次请求都会重设。一般我会在结合钩子函数在请求处理前使用。
具体是怎么实现的呢?
上下文具体的实现文件:ctx.py
请求上下文对象通过RequestContext类实现,当Flask程序收到请求时,会在wsgi_app()中调用Flask.request_context(),实例化RequestContext()作为请求上下文对象,接着会通过push()方法将请求数据推入到请求上下文堆栈(LocalStack),然后通过full_dispatch_request对象执行视图函数,调用完成之后通过auto_pop方法来移除。所以,请求上下文的生命周期开始于调用wsgi_app()时,结束与响应生成之后。具体代码:
def wsgi_app(self, environ, start_response):
ctx = self.request_context(environ)
error = None
try:
try:
ctx.push()
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except: # noqa: B001
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
程序上下文对象通过AppContext类实现,程序上下文的创建方式有两种:
- 自动创建:在处理请求时,程序上下文会随着请求上下文一起被创建
- 手动创建:with语句
通过阅读源码,可以看到上面两个上下文对象的push和pop都是通过操作LocalStack对象实现的,那么,LocalStack是怎样实现的呢?
Werkzeug的LocalStack是栈结构,在 globals.py中定义:
_request_ctx_stack = LocalStack()
_app_ctx_stack = LocalStack()
具体的实现:
class LocalStack(object):
def __init__(self):
self._local = Local()
def __release_local__(self):
self._local.__release_local__()
def _get__ident_func__(self):
return self._local.__ident_func__
def _set__ident_func__(self, value):
object.__setattr__(self._local, '__ident_func__', value)
__ident_func__ = property(_get__ident_func__, _set__ident_func__)
del _get__ident_func__, _set__ident_func__
def __call__(self):
def _lookup():
rv = self.top
if rv is None:
raise RuntimeError('object unbound')
return rv
return LocalProxy(_lookup)
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
可以看到:
- LocalStack实现了栈的push、pop和获取栈顶数据的top数据
- 整个类基于Local类,在构造函数中创建Local类的实例_local,数据是push到Werkzeug提供的Local类中
- 定义
__call__
方法,当实例被调用直接返回栈顶对象的Werkzeug提供的LocalProxy代理,即LocalProxy实例,所以,_request_ctx_stack
和_app_ctx_stack
都是代理。
看到这里,就有以下问题:
Local类是怎样存储数据的呢?为啥需要存储到Local中?
先看下代码:
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):
__slots__ = ("__storage__", "__ident_func__")
def __init__(self):
object.__setattr__(self, "__storage__", {})
object.__setattr__(self, "__ident_func__", get_ident)
def __iter__(self):
return iter(self.__storage__.items())
def __call__(self, proxy):
"""Create a proxy for a name."""
return LocalProxy(self, proxy)
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)
可以看到,Local构造函数中定义了两个属性:
-
__storage__
:用来保存每个线程的真实数据,对应的存储结构为->{线程ID:{name:value}}
-
__ident_func__
:通过get_ident()方法获取线程ID,可以看到优先会使用Greenlet获取协程ID,其次是thread模块的线程ID
Local类在保存数据的同时,记录对应的线程ID,获取数据时根据当前线程的id即可获取到对应数据,这样就保证了全局使用的上下文对象不会在多个线程中产生混乱,保证了每个线程中上下文对象的独立和准确。
可以看到,Local类实例被调用时也同样的被包装成了一个LocalProxy代理,为什么要用LocalProxy代理?
代理是一种设计模式,通过创建一个代理对象来操作实际对象,简单理解就是使用一个中间人来转发操作,Flask上下文处理为什么需要它?
看下代码实现:
@implements_bool
class LocalProxy(object):
__slots__ = ('__local', '__dict__', '__name__', '__wrapped__')
def __init__(self, local, name=None):
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:
raise RuntimeError('no object bound to %s' % self.__name__)
@property
def __dict__(self):
try:
return self._get_current_object().__dict__
except RuntimeError:
raise AttributeError('__dict__')
def __repr__(self):
try:
obj = self._get_current_object()
except RuntimeError:
return '<%s unbound>' % self.__class__.__name__
return repr(obj)
def __bool__(self):
try:
return bool(self._get_current_object())
except RuntimeError:
return False
def __unicode__(self):
try:
return unicode(self._get_current_object()) # noqa
except RuntimeError:
return repr(self)
def __dir__(self):
try:
return dir(self._get_current_object())
except RuntimeError:
return []
def __getattr__(self, name):
if name == '__members__':
return dir(self._get_current_object())
return getattr(self._get_current_object(), name)
def __setitem__(self, key, value):
self._get_current_object()[key] = value
def __delitem__(self, key):
del self._get_current_object()[key]
...
通过__getattr__()
、__setitem__()
和__delitem__
会动态的更新实例对象。
再结合上下文对象的调用:
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"))
我们可以很明确的看到:因为上下文的推送和删除是动态进行的,所以使用代理来动态的获取上下文对象。
以上,希望你对Flask上下文机制的原理有了清晰的认识。
- 提供第三种代码生成方式——通过自定义BuildProvider为ASP.NET提供代码生成
- 小心,Android木马工具SpyNote免费啦!远程监听就是这么简单
- R语言的kmeans客户细分模型聚类
- .NET的资源并不限于.resx文件,你可以采用任意存储形式[下篇]
- 量化投资教程:用R语言打造量化分析平台
- 也谈事件(Event)
- Zuul:构建高可用网关之多维度限流
- Hystrix:HystrixCollapser请求合并
- oauth2.0 实现spring cloud nosession
- 基于自定义向导的C++单元测试环境自动化配置
- 【spring cloud】自定义jwt实现spring cloud nosession
- R语言的三种聚类方法
- ArrayList foreach 循环里进行元素的 remove add 操作有什么现象?
- 10个令人相见恨晚的R语言包
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法
- 持续部署入门:基于 Kubernetes 实现蓝绿发布
- PHP 实现Redis发布订阅消息及时通讯
- 简单几步,用云开发搞定短信验证码登录
- 重要的进程就让Supervisor 来守护吧!
- 机器学习基础:令你事半功倍的pipeline处理机制
- django 中如何将字典变量传给template视图层的JS
- Spring第三天:Spring的AOP的注解开发、Spring的声明式事务、JdbcTemplate
- Spring Boot中集成Slf4j 与Logback
- 一文搞定 Linux 常用高频命令
- 推荐一款科研必备的Python数据可视化神器——PyQtGraph
- 机器学习基础:可视化方式理解决策树剪枝
- 神级代码注释-这次是来搞笑的
- Gremlin 图查询概述
- JS,PHP,Python,Java对JSON数据的处理
- 基于Canal与Flink实现数据实时增量同步(二)