Flask请求应用上下文源码分析
Flask请求应用上下文源码分析
一、pipreqs的使用
# 咱们写项目，项目的依赖，requirements.txt
# 多种方式实现
-手写
-虚拟环境：pip freeze > requirements.txt
-使用第三方插件自动生成：只生成当前项目所依赖的模块
- 项目依赖 pip3 install pipreqs==0.4.0
- 项目根路径下执行，生成依赖文件：pipreqs ./ --encoding=utf-8
- 安装依赖文件：pip3 install -r requirements.txt
二、函数和方法
# 函数就是普通函数，不会自动传值
# 方法是函数，但是它会自动传值，面向对象中概念
# 方法，你得看谁来调用，如果类调用对象的方法，它就变成了普通函数，就不是方法了
from types import MethodType, FunctionType
class Foo(object):
def fetch(self): # 绑定给对象的方法，正常应该对象来掉用，就是方法
pass
print(isinstance(Foo.fetch, MethodType)) #False，变成了函数
print(isinstance(Foo.fetch, FunctionType)) # True
obj = Foo()
print(isinstance(obj.fetch, MethodType)) # True
print(isinstance(obj.fetch, FunctionType)) # False
三、偏函数
from functools import partial
# 提前传参，延迟计算
def add(a, b, c):
return a + b + c
# res=add(3,4,5)
# print(res)
res = partial(add, 3)
# res 就是偏函数，提前先给add函数传了一个参数3，还没执行add，以后执行传两个参数就可以了，使用res
# print(res)
r=res(4,5)
print(r)
四、local对象
# 多线成并发操作一个变量，会导致数据错乱，可以使用互斥锁加锁处理数据不安全的情况 （临界区）
# 使用local对象处理，多个线程操作的变量是local对象，就不会有并发安全的问题----》因为它处理了并发安全的问题---》大字典，key值是线程id号，value是个字典
{
123:{
'name':lqz},222:{
'name':egon}}
l=local()
l.name='lqz'--->l[123][name]
l.name='egon'
基本使用
# 1 不使用local，多线程并发操作，数据错乱
# import time
# from threading import Thread
# class Local():
# pass
#
# l = Local()
#
# def task(name):
# l.name = name
# time.sleep(1)
# print('在线程内的名字是:', name, 'l对象中的名字大概率不一样', l.name)
#
#
# if __name__ == '__main__':
# for i in range(10):
# t = Thread(target=task, args=['egon' + str(i) + '号', ])
# t.start()
#
# # 等待所有线程都执行完成再执行下面代码
# time.sleep(6)
# print(l)
# 2 使用local
import time
from threading import Thread
from threading import local
# 定义一个全局变量，并发安全的local，多个线程操作，不会错乱，因为每个线程用的都是自己的数据
l = local()
def task(name):
l.name = name
time.sleep(1)
print('在线程内的名字是：', name, 'l对象中的名字也是', l.name)
if __name__ == '__main__':
for i in range(10):
t = Thread(target=task, args=['egon' + str(i) + '号', ])
t.start()
# 等待所有线程都执行完成再执行下面代码
time.sleep(6)
print(l)
自己写一个local类，线程和协程并发安全
# 3 local不能处理协程安全，自己实现一个
### 3.1 第一个版本
# from threading import get_ident,Thread
# import time
# storage = {}
# def set(k,v):
# ident = get_ident() # 线程id号
# if ident in storage:
# storage[ident][k] = v
# else:
# storage[ident] = {k:v}
# def get(k):
# ident = get_ident()
# return storage[ident][k]
# def task(arg):
# set('val',arg) #
# v = get('val')
# print(v)
#
#
# # 10个线程跑完，最终storage={123:{val:0},222:{val:1},333:{val:2},444:{val:3}.....}
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
## 3.2 使用面向对象
# from threading import get_ident,Thread
# import time
# class Local(object):
# storage = {}
# def set(self, k, v):
# ident = get_ident()
# if ident in Local.storage:
# Local.storage[ident][k] = v
# else:
# Local.storage[ident] = {k: v}
# def get(self, k):
# ident = get_ident()
# return Local.storage[ident][k]
# obj = Local()
# def task(arg):
# ob6j.set('val',arg)
# v = obj.get('val')
# print(v)
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
### 3.3 __setattr__和__getattr__方法版
# from threading import get_ident,Thread
# import time
# class Local(object):
# storage = {}
# def __setattr__(self, k, v):
# ident = get_ident()
# if ident in Local.storage:
# Local.storage[ident][k] = v
# else:
# Local.storage[ident] = {k: v}
# def __getattr__(self, k):
# ident = get_ident()
# return Local.storage[ident][k]
# obj = Local()
# def task(arg):
# obj.val = arg
# print(obj.val)
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
### 3.4 每个local对象用自己的存储空间
# from threading import get_ident, Thread
# import time
#
#
# class Local(object):
# def __init__(self):
# # self.storage={}
# object.__setattr__(self, 'storage', {})
#
# def __setattr__(self, k, v):
# ident = get_ident() # 获取线程id号
# if ident in self.storage:
# self.storage[ident][k] = v
# else:
# self.storage[ident] = {k: v} #
#
# def __getattr__(self, k):
# ident = get_ident()
# return self.storage[ident][k]
#
#
# obj = Local()
#
#
# def task(name):
# obj.name = name
# print(obj.name)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
### 3.5 兼容协程
try:
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
from threading import Thread
import time
class Local(object):
def __init__(self):
object.__setattr__(self,'storage',{
})
def __setattr__(self, k, v):
ident = get_ident()
if ident in self.storage:
self.storage[ident][k] = v
else:
self.storage[ident] = {
k: v}
def __getattr__(self, k):
ident = get_ident()
return self.storage[ident][k]
obj = Local()
def task(arg):
obj.val = arg
obj.xxx = arg
print(obj.val)
for i in range(10):
t = Thread(target=task,args=(i,))
t.start()
五、flask请求上下文源码分析
首先明确一点为什么flask中的request请求是全局变量，为什么不是django的来一个请求就带着一个request。flask是怎么做到张三发了两次请求，在程序层面就确定这两次请求就是张三的，而不是一个张三另一个是李四的呢？
请求上下文执行流程（ctx）：
-0 flask项目一启动，有6个全局变量
-_request_ctx_stack：LocalStack对象----》封装了local
-_app_ctx_stack ：LocalStack对象
-request ： LocalProxy对象
-session ： LocalProxy对象
-1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
-2 wsgi_app()
-2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session
-2.2 执行： ctx.push()：RequestContext对象的push方法
-2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
-2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
-2.2.3 push方法源码：
def push(self, obj):
#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
#Local()flask封装的支持线程和协程的local对象
# 一开始取不到stack，返回None
rv = getattr(self._local, "stack", None)
if rv is None:
#走到这，self._local.stack=[],rv=self._local.stack
self._local.stack = rv = []
# 把ctx放到了列表中
#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
rv.append(obj)
return rv
-3 如果在视图函数中使用request对象，比如：print(request)
-3.1 会调用request对象的__str__方法，request类是：LocalProxy
-3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
-3.2.1 内部执行self._get_current_object()
-3.2.2 _get_current_object()方法的源码如下：
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
#self.__local() 在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
# 用了隐藏属性
#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
#这个地方的返回值就是request对象(当此请求的request，没有乱)
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
-3.2.3 _lookup_req_object函数源码如下：
def _lookup_req_object(name):
#name是'request'字符串
#top方法是把第二步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
#通过反射，去ctx中把request对象返回
return getattr(top, name)
-3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
-4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
-5 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉
其他的东西：
-session:
-请求来了opensession
-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
if self.session is None:
#self是ctx，ctx中有个app就是flask对象， self.app.session_interface也就是它：SecureCookieSessionInterface()
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
#经过上面还是None的话，生成了个空session
self.session = session_interface.make_null_session(self.app)
-请求走了savesession
-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
-请求扩展相关
before_first_request，before_request，after_request依次执行
-信号的触发
信号名.send()
-flask有一个请求上下文，一个应用上下文
-ctx:
-是：RequestContext对象:封装了request和session
-调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
-app_ctx:
-是：AppContext(self) 对象：封装了当前的app和g
-调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
-g是个什么鬼？
专门用来存储用户信息的g对象，g的全称的为global
g对象在一次请求中的所有的代码的地方，都是可以使用的
-代理模式
-request和session就是代理对象，用的就是代理模式
-g是个什么鬼？
专门用来存储用户信息的g对象，g的全称的为global
g对象在一次请求中的所有的代码的地方，都是可以使用的 (当次请求中传递一些数据)
-g对象和session的区别
g对象只对当次请求有效（当此请求内有效）
session：可以跨请求，该用户的多次请求中都可以使用