Flask 上下文管理-- (session,request,current_app的传递)--类似本地线程实现，以及多app应用

Flask session,request,current_app的传递

请求上下文的作用 -- 封装请求相关得数据(request,session)

请求上下文

request
session

request local类 {线程，协程的唯一ID:{stack:[RequestContext(request,session)]}}

应用上下文

app local类 {线程，协程的唯一ID:{stack:[AppContext(app,g)]}}

app 保存着 应用相关的值

g 每次请求周期都会创建一个用于在请求周期中传递值 的 容器

1 flask的 request, session 和 current_app 都是 设置方式比较新颖 -- 通过上下文管理的方式实现的

类似于本地线程 threading_local ,创建Local类

local = {
'线程或者协程的唯一标识':{'stack':[RequestContext(),]}， # a 每个线程一份
'线程或者协程的唯一标识':{'stack':[RequestContext(),]}， # b
'线程或者协程的唯一标识':{'stack':[RequestContext(),]}， # c
'线程或者协程的唯一标识':{'stack':[RequestContext(),]}， # d
'线程或者协程的唯一标识':{'stack':[RequestContext(),]}， # e

}

每次请求进来app.run调用 call 方法， 将包含了所有请求相关数据的实例对象RequestContext()添加， 通过stack(键)，push到一个地方Local中，使用的时候再去取(top方法取值)，在请求结束后返回的时候 pop 掉

与Django的区别

请求相关数据的传递方式 ：

Django
参数一个一个传递

Flask
基于Local(类似于本地线程)和LocalStack(push, pop, top)完成
参数不用来回传递, 直接获取reqeust

多个请求一起数据也不会混淆

单线程 - - 每次只能有一个请求处理
多线程 - - 通过Local实现不同的数据划分 - - thread - -线程的唯一标识
协程 - - greenlet - - 协程的唯一标识

flask 的上下文管理机制描述

（1） 与django相比是两种不同的方式实现：

django/tornado 是通过传参的方式

flask 第通过上下文管理机制

两种都可以实现，只是实现的方式不一样

（2）类似 threading local 机制，
flask创建 一个local类 {线程，协程的唯一ID:{stack:[RequestContext(request,session)]}} 保证数据隔离

请求进来 把ReqeustContext对象 push到 对应的stack中
使用 的时候 通过localstack的top方法，获取local中的reqeust
请求终止 通过localstack pop方法，删除local的request

2 补充 partial 函数

其实就是函数调用的时候，有多个参数 参数，但是其中的一个参数已经知道了，我们可以通过这个参数重新绑定一个新的函数，然后去调用这个新函数。

from functools import partial

def f(a,b):
return a + b

f1 = partial(f,10)

print(f1(5))
-->> 15

3 唯一标识

基于 Local类

类似于本地线程theading_local -->> 每一个线程 创建一个

from greenlet import getcurrent as get_ident
可以基于 greenlet -->> 粒度更细

比如 wsgi -- 有基于线程的，也有基于协程实现的

本地线程：

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()

4 多app应用，以及web'访问多app时的上下文

多app应用，通过前缀做分发

from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple

app1 = Flask('app1')
app2 = Flask('app2')

@app1.route('/index')
def index():
return 's'

@app2.route('/index')
def index():
return 's'

dm = DispatcherMiddleware(app1,{'/app2':app2})

if name == 'main':
run_simple('localhost',5000,dm)

同时并发的请求 app1 和 app2，请求上下文Local类中 {
'ID app1'：{stack:[ReqeustContext,]},
'ID app2'：{stack:[ReqeustContext,]},
}

5 补充 with .. 上下文管理

class SQLHelper(object):

def enter(self):
print('开始')
self.open()
return self

def open(self):
pass

def fetch(self):
pass

def close(self):
pass

def exit(self, exc_type, exc_val, exc_tb):
print('结束')
self.close()

with SQLHelper() as f:
pass

6 为什么 flask的 local 保存数据要使用 列表建成的栈

如果是 web 程序，栈中永远是 一条数据 （可以不使用栈）

如果是 脚本测试 出现如下的上下文嵌套 ，会出现 多条数据

from flask import Flask,current_app,_app_ctx_stack

app1 = Flask(name)
app1.config['DEBUG'] = True

app2 = Flask(name)
app2.config['DEBUG'] = False

with app1.app_context():
print(_app_ctx_stack._local.storage)
print(current_app.config['DEBUG']) # current_app _app_ctx_stack.top [-1]

with app2.app_context():
print(_app_ctx_stack._local.storage)
print(current_app.config['DEBUG'])

{5116: {'stack': [<flask.ctx.AppContext object at 0x00000000038C55C0>, <flask.ctx.AppContext object at 0x00000000038C5748>]}} False