flask中间件和LOCAL对象
中间件
我们知道 app.run()之后，会调用__call__()方法，看一下他的源码
def __call__(self, environ, start_response):
"""The WSGI server calls the Flask application object as the
WSGI application. This calls :meth:`wsgi_app` which can be
wrapped to applying middleware."""
return self.wsgi_app(environ, start_response)
就这么多，这里的self就是我们的app，一旦调用了app的wsgi_app方法，我们就不能插足了，所以中间件要在调用这个之前写。怎么实现呢，就是
from flask import Flask,flash,get_flashed_messages,request
app = Flask(__name__)
class MyMiddleware:
def __init__(self,wsgi_app):
#实例化对象的时候就会走这个方法，传进来的wsgi_app是原生的，复制给了对象的属性
self.wsgi_app=wsgi_app
#类的__call__,对象加括号的时候会调用，在上面的源码里，就是self.wsgi_app(environ, start_response)，这里的self.wsgi_app是MyMiddleware类的对象，所以会执行这里的__Call__
def __call__(self, environ, start_response):
#自己想要通过中间件实现的功能就可以写在这里了。
print("123")
res=self.wsgi_app(environ, start_response)
print("456")
print(res)
return res
@app.route('/index')
def index():
# request.method
# session['sd']
return "ssdsdsdfsd"
if __name__ == '__main__':
#代码从这里开始走，先实例化一个自己生成的类的对象，把原来的app.wsgi_app当做参数传给类的__init__，生成的对象赋值给新的app.wsgi_app
app.wsgi_app = MyMiddleware(app.wsgi_app)
app.run()
LOCAL对象
我们在使用多线程的时候会有一个问题，那就是数据不安全问题
from threading import Thread
import time
cxw = -1
def task(arg):
global cxw
cxw = arg
time.sleep(2)
print(cxw)
for i in range(10):
t = Thread(target=task,args=(i,))
t.start()
打印结果发现，所有的cxw都是9，按照我们原来的想法结果应该是0123456789这样，但是睡了两秒之后，最后一个线程早就把cxw变成9了。
通常解决这种问题我们会使用线程锁，但是也可以用local来实现
导入的local
from threading import Thread
from threading import local
import time
# 特殊的对象
cxw = local()
def task(arg):
# 对象.val = 1/2/3/4/5
cxw.value = arg
time.sleep(2)
print(cxw.value)
for i in range(10):
t = Thread(target=task,args=(i,))
t.start()
这时候打印出来的内容就是正确的了，但不一定是按顺序的（cpu的调度问题）。那么这个到底是怎么实现的。
原理是类似于字典一样的存取值方式。获取当前的线程的id，来存入对应的值，取的时候也是同样，根据线程的id值来取，这样就实现了。
from threading import get_ident,Thread
import time
storage = {}
def set(k,v):
#获取当前线程的id
ident = get_ident()
#判断当前这个线程的id存不存在于这个storage，存在的话就设置一个值
if ident in storage:
#这里设置完之后结果类似于 {"pid1号":{k:v},}
storage[ident][k] = v
else:
#不存在这个pid号的话，就设置一个
storage[ident] = {k:v}
for i in range(10):
t = Thread(target=task,args=(i,))
t.start()
面向对象的形式：
面向对象的形式
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):
obj.set('val',arg)
v = obj.get('val')
print(v)
for i in range(10):
t = Thread(target=task,args=(i,))
t.start()
以上版本均有问题，以下才是最终版
最终版：
try:
#不仅可以实现多线程，还可以实现协程
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
from threading import Thread
# from threading import get_ident,Thread
import time
class Local(object):
#为什么要把初始化strorage的语句放在__init__里面，也就是说把它变为对象的属性，而不是类的属性，因为一个项目可能在别的地方也会调用 Local，这时候大家用的就是共同的storage了，所以要把它设置为对象的属性
def __init__(self):
#为什么这里要调用功父类的__setattr__？因为如果直接用self.storage={}的话，会调用__setattr__，在自己的__setattr__里面的self.storage会调用__getattr_，然后在__getattr__中会发生递归，不停地调用自己。所以这里要调用父类的__setattr__，就像我们以前正常的赋值（dic['a']=1）一样。
object.__setattr__(self,'storage',{})
#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()
