flask基础third，中间件,猴子补丁,蓝图,线程,flask源码

一、中间件(与Django中间件完全不一样)

　　在执行原来的app.wsgi_app之前可以加入自己的逻辑，在之后也可以加入自己的逻辑，ret = self.old_wsgi_app(environ, start_response)被称为中间件

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return 'Hello World!'
# 模拟中间件
class Md(object):
    def __init__(self,old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app

    def __call__(self,  environ, start_response):
        print('执行之前')                              #这里可以加入自己的逻辑
        ret = self.old_wsgi_app(environ, start_response)
        print('执行之后')　　　　　　　　　　　　　　　　　　#这里也可以加入自己的逻辑
        return ret

if __name__ == '__main__':
    #1我们发现当执行app.run方法的时候，最终执行run_simple，最后执行app(),也就是在执行app.__call__方法 
    #2 在__call__里面，执行的是self.wsgi_app().那我们希望在执行他本身的wsgi之前做点事情。
    #3 所以我们先用Md类中__init__，保存之前的wsgi,然后我们用将app.wsgi转化成Md的对象。
    #4 那执行新的的app.wsgi_app，就是执行Md的__call__方法。
    #把原来的wsgi_app替换为自定义的，
    
    app.wsgi_app = Md(app.wsgi_app)
    app.run()

二、猴子补丁　　

　　只是一个概念，不属于任何包和模块。利用了python一切皆对象的理念，在程序运行过程中，动态修改方法

　　概念

class Monkey():
    def play(self):
        print('猴子')

class Dog():
    def play(self):
        print('狗子')

m=Monkey()         #先实例化类
m.play()               #结果为猴子

m.play=Dog().play
m.play()               #结果为狗子

　　用处：动态修改原来的方法或者是模块

 　　这里有一个比较实用的例子, 很多用到import json, 后来发现ujson性能更高, 如果觉得把每个文件的import json改成import ujson as json成本较高, 或者说想测试一下ujson替换是否符合预期, 只需要在入口加上: 只需要在程序入口写如下代码即可：此时调用json方法实际上调用的是ujson方法。

import json
import ujson

def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()

aa=json.dumps({'name':'lqz','age':19})
print(aa)

　　对比分析协程：单线程下实现并发

from gevent import monkey;monkey.patch_all()
import gevent
import time
def eat():
    print('food 1')
    time.sleep(2)                #可以放置所有阻塞事件
    print('food 2')
 
def play():
    print('play 1')
    time.sleep(1)                #可以放置所有阻塞事件
　　 print('play 2') 

g1=gevent.spawn(eat) 
g2=gevent.spawn(play) 
gevent.joinall([g1,g2])          #此时就管理两个事物，遇到io就自动切 
print('主')

三、蓝图

　　没有蓝图之前前，都是单文件
　　对于蓝图可以分文件，分app，之前的请求扩展还是一样用（除before_first_request只在app上，蓝图上没有），只是在当前蓝图对象管理下的有效。
　　蓝图使用
　　　　第一步在app中注册蓝图，括号里是一个蓝图对象
    　　　　app.register_blueprint(user.us)
　　　　第二步，在不同文件中注册路由时，直接使用蓝图对象注册，不在使用app注册，避免了循环导入的问题
    　　　　@account.route('/login.html', methods=['GET', "POST"])

概念及使用：

先新建一个项目（如下面的中小型项目文件布局，那么此时就在pro_flask的init.py里面写注册蓝图的代码），里面有static包、templates包、views包以及一个和views同级别的run.py启动文件。views里面有init.py、user.py、order.py。

#views下init.py里面的代码
    from flask import Flask
    app = Flask(__name__,template_folder='templates',static_folder='static',static_url_path='/static')        #配置静态文件路径，就相当于暴露静态文件，前端可以直接访问

    from . import user                 #必须要导入views里面的视图模块
    from . import order
    
    #注册蓝图
    app.register_blueprint(user.us)
    app.register_blueprint(order.ord)

#order里面的代码
    from flask import Blueprint
    ord = Blueprint('order',__name__)         #以后再注册路由，使用蓝图对象，在视图init方法里已经注册了。APP对象的功能，蓝图就有什么功能
    @ord.route('/order')                      #这里就不使用@app.route('/order'),而是使用蓝图对象
    def user():
        return 'order'

#user里面的代码
    from flask import Blueprint
    us = Blueprint('user',__name__)        
    @us.route('/user')
    def user():
        return 'user'

#run里面就是一个启动文件，代码
    from views import app
    if __name__ == '__main__':
        app.run()

　　中小型项目目录划分
    　　项目名字
        　　-pro_flask文件夹     (这个文件夹放置templates、statics、views)
        　　　　-__init__.py
        　　　　-templates       （模板）
            　　　　-login.html
        　　　　-statics            （静态文件）
            　　　　-code.png
        　　　　-views             （视图文件）
            　　　　-blog.py
            　　　　-account.py
            　　　　-user.py
        　　-run.py                   （和pro_flask同级别，为启动文件）
        
　　大型项目（然后各个模块的init.py文件夹里面的代码指定暴露静态文件与上面一样，大型项目就是中小型项目组合起来的）
    　　项目名
        　　-pro_flask文件夹
            　　-__init__.py

#此时大型项目里面的文件夹init.py
from flask import Flask
from .admin import admin
from .web import web

app=Flask(__name__)
app.debug = True

#此时的蓝图注册
app.register_blueprint(admin,url_prefix='/admin')
app.register_blueprint(web,url_prefix='/web')

#此时像上面一样指定url_prefix，访问蓝图的地址就是http://127.0.0.1:5000/admin/xxx

            　　-web
                　　-__init__.py
                　　-static
                　　-views.py
                　　-templates

            　　-admin

                　　-templates
                　　-static
                　　-views.py
                　　-__init__.py
        　　-run.py

四、threading.local

　　1、不使用local，多线程下写同一个数据会错乱

from threading import Thread
import time
sss = -1
def task(arg):
    global lqz
    sss = arg
    time.sleep(2)
    print(sss)
    
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()

#此时同时开启10条线程，但是数据会错乱，所以输出结果是同时打印出10个9

　　2、使用local对象，多线程写同一数据不会错乱，因为每个线程操作自己的数据，存储方式为：{'线程id'：{value:1},'线程id'：{value:2}....}。所以不会错乱

from threading import Thread
from threading import local
import time
from threading import get_ident

sss = local()
#此时运行就是{'线程id'：{value:1},'线程id'：{value:2}....}
def task(arg):
    sss.value = arg
    time.sleep(2)
    print(sss.value)
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()

#此时多线程操作同一个数据，并不会乱，输入0-9的数字

　　3、自己定义一个类似local的东西，函数版本

from threading import get_ident,Thread
import time
storage = {}
#{'线程id'：{value:1},'线程id'：{value:2}....}

#设置线程id号
def set(k,v):
    ident = get_ident()
    if ident in storage:
        storage[ident][k] = v
    else:
        storage[ident] = {k:v}

#取线程id号
def get(k):
    ident = get_ident()
    return storage[ident][k]

#执行任务
def task(arg):
    set('val',arg)
    v = get('val')
    print(v)

for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()        

#也是打印0-9

　　4、自己定义一个类似local的东西，面向对象版本，就是将上面的函数封装成一个类

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)
    time.sleep(1)
    v = obj.get('val')
    print(v)
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()           

　　5、每次实例化得到一个local对象，用自己的字典存储（此时只支持线程）

from threading import get_ident,Thread
import time
class Local(object):
    def __init__(self):
        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
    time.sleep(1)
    print(obj.val)
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()
        

　　6、支持协程（flask框架里面内置，可以查看local源码）

五、flask源码上下文执行流程分析

　　补充：partial(),偏函数可以提前传参数，后面再调用就不用传之前传过的参数了。

请求上下文执行流程步骤：         -启动初始：有6个全局变量，顶格写的，只要flask启动，他就会执行，直到flask停掉才回收             -_request_ctx_stack：LocalStack()对象             -_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 ，这个只有内部才能看到，因为是__方法，所以前面传入_LocalProxy__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依次执行                 -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就是代理对象，用的就是代理模式LocalProxy，用代理去拿