Flask

一，Flask初识

　　Python现阶段三大主流web框架Django,Tornad,Flask对比

　　　　1.Django主要特点是大而全，集成了很多组件，例如：Models Admin Form等等，不管是否用上，它全都有，属于全能型框架，Django通常用于大型web应用由于内置组件足够强大所以使用Django开发可以一气呵成，缺点是浪费资源，一次性加载全部资源，肯定会造成一部分资源的浪费想·

　　　　2.Tornado主要特点是原生异步非阻塞，在IO密集型应用和多任务处理上占据绝对性的优势，属于专注型框架，通常用于api后端应用，游戏服务后台，内部实现的异步非阻塞非常牛逼，缺点是干净，不支持Session

　　　　3.Flask主要特点小而轻，原生组件几乎为0,三方提供的组件请参考django非常全面，属于短小精悍型框架，通常应用于小型应用和快速构建应用，其强大的三方库，足以支撑一个大型的web应用

　　Flask 安装

pip install flask

二，Flask的WSGI网关接口协议

 WSGI网关接口协议
    django：
       wsgi_ref 封装request,封装socket,一般用于django本地测试
　　　　uwsgi django上线使用，性能更好
    flask:
     Werkzeug是Python的WSGI规范的实用函数库。使用广泛，基于BSD协议
       werkzeug为Flask封装了socket
                from werkzeug.wrappers import Request, Response
                from werkzeug.serving import run_simple

                @Request.application
                def run(request):
                    return Response("hello~~")

                if __name__ == '__main__':
                    run_simple('localhost', 5000, run)
      # 功能特性
        HTTP头解析与封装
        易于使用的request和response对象
        基于浏览器的交互式JavaScript调试器
        与 WSGI 1.0 规范100%兼容
        支持Python 2.6,Python 2.7和Python3.3
        支持Unicode
        支持基本的会话管理及签名Cookie
        支持URI和IRI的Unicode使用工具
        内置支持兼容各种浏览器和WSGI服务器的实用工具
        集成URL请求路由系统

三，Flask的demo

from flask import Flask

# 注意静态文件以及模板的配置
# 默认tamplates static
app = Flask(__name__)

@app.route("/")
def index():
    return # 可以返回的类型 render_templage()/redirect()/"字符串"

app.run()

四，Flask的配置文件

# 配置文件
      #  配置信息 app.config
      #  修改配置信息 app.config["DEBUG"] = True
      #  解耦写法
        -- settings.py
                class DEVConfig(object):
                    DEBUG = True
                    SECRET_KEY = "jalksdjgajh"


                class ProConfig(object):
                    DEBUG = False


               class TestConfig(object):
                    TESTING = True

    -- app.config.from_object("settings.DEVConfig")    # from_object设置配置文件类  

# 可以直接用app.配置的项
app.testing
app.secret_key
app.session_cookie_name
app.permanent_session_lifetime
app.send_file_max_age_default
app.use_x_sendfile

五，Flask的路由

# 一般的路由
    @app.route("/book") 

# 带参数的路由 
    @app.route("/book/<int:nid>")  # 参数类型 不设置数据类型 则默认为str类型
    # 参数的数据类型：略

# 路由的命名：
     @app.route("/book",endpoint="book") # 不配置的话，endpoint默认为视图函数名

# 命名路由的反向解析
    from flask import url_for
    url_for("name",nid=xxx) # => /book/123
    
return redirect(url_for("xxx",nid='xx'))

 　　路由的实现原理

@app.route("/index")  # 带参数的装饰器
decorator = app.route("/index")

# 源码
def route(self, rule, **options):
    def decorator(f):
        endpoint = options.pop('endpoint', None)
        self.add_url_rule(rule, endpoint, f, **options)
        return f
return decorator

@decorator
def index():
    pass
app.add_url_rule(rule,endpoint=None,view_func=视图函数)
# 可以通过这个方式来创建对象关系

　　路由的正则匹配

# 源码自带的正则匹配类
UnicodeConverter
AnyConverter
PathConverter
NumberConverter
IntegerConverter
FloatConverter
UUIDConverter

# 自定义正则
    class RegexConverter(BaseConverter):
        # 自定义URL匹配正则表达式
        def __init__(self,map,regex):
            super(RegexConverter,self).__init__(map)
            self.regex = regex

        def to_python(self,value):
            # 路由匹配是，匹配成功后传递给视图函数中参数的值
            return int(value)

        def to_url(self,value):
            # 使用url_for 反向生成URL时,传递的参数经过该方法处理,返回值用于生成URL参数
            val = super(RegexConverter,self).to_url(value)
            return val

    # 添加到flask中
    app.url_map.converters['regex'] = RegexConverter

    @app.route("/index/<regex("d+"):nid>")
    def index(nid):
        print(url_for("index",nid="888"))
        print(nid)
        print(type(nid))
        return "Index"

六，Flask的请求相关以响应相关

# 请求相关
     # flask的request不如django一样贯穿整个请求的声明周期，那么python怎么识别哪个请求对的哪个request呢：
        以协程作为唯一标志为key：具体请求的数据为value  # 使用历史于字典的数据结构
    
    from flask import request
        # 常用的请求相关的数据
        request.method # 请求类型
        request.headers # 请求头
        request.args  # url的参数?xx=xx
        reuqest.form # 表单的数据
        request.files  # 上传文件
        request.path  # 获取url 
        request.full_path  # 获取完整url
            # 上传文件
            obj = request.files['file_name']
            obj.save('/var/www/uploads/'+ secure_filename(f.filename))

# 响应相关
       # response三种类型
            return str
            return render_template
            return redirect

       # 自定义响应
            from flask import make_response
            # 封装响应对象
            response = make_response(render_template("xxx.html"))
            response.set_cookie("key","value")  # 设置cookie
            response.header["X-Something"] = "A value"  # 设置响应头
            return response  

七，Flask的模板渲染

# flask的模板渲染 跟django的模板语言 基本相同
    # 区别
       # 函数的执行需要加() 
        {{my_func()|safe}}

       # 字典的三种取值方式
            {{ my_dict.ages }}
            {{ my_dict.["ages"] }}
            {{ my_dict.get("ages", 0) }}
       
       # 给页面传递数据，包括函数
       return render_template("xxx.html",**{"book_list":book_list,"myfunc":myfunc})

八，Session

# session
    flask的session底层:base64
    app.config["SECRET_KEY"]="xx"  # 配置盐
    session['userinfo'] = {"name":name }    # 设置session
    session.get("userinfo")     # 在session中取值
    session.pop("key")  # 删除

# flash 闪现：只能在一个请求里拿值
    from flask import flash,get_flashed_message    

    # 原理
          #  设置值的时候 session["xxx"]=value
                flash("value","key")
                
          # 取值 session.pop("xxx")
                name = get_flashed_messages()
                name = get_flashed_messages(category_filter=["name"])

九，视图

# 路由的实现原理
    # @app.route("/index")
    decorator = app.route("/index")
    @decorator
    def index():
        return "xxx"

    app.add_url_rule(rule,endpoint,f)
       # rule = "/index"
       # endpoint = 别名
       # f = 视图函数名
   # 注意在add_url_rule方法里
   #     endpoint默认取函数名
   #     两个函数不能用一个endpoint

# CBV编程
    class MyView(views.MethodView):
        decorators = [auth,]
        methods = ["GET","POST"]

        def get(self):
            return "GET"

        def post(self):
            return "POST"

    app.add_url_rule("/index",view_func=MyView.as_view(name="index"))  # name ==> endpoint

十，中间件

# 中间件
  #  Flask 请求的入口
       # 1. app.run() ==> run_simple()
       # 2. werkzoug的run_simple(host,port,self,**option)
       # 3. self() --> app()
           # app() --> Flask.__call__()
       # 4. __call__ => return self.wsgi_app(*args,**kwargs)
   # 实现中间件
      #  改源码(不推荐..)
      #  类实现
            class Middleware(object)
                def __init__(self,old_wsgi_app)
                    self.old = old_wsgi_app
                def __call__(self,*args,**kwargs):
                    # 请求前做某操作
                    ret self.old(*args,**kwargs)
                    # 请求后做某操作
                    return ret
            
            # 把Flask().wsgi_app当成蚕食传递给了Middleware
            # app.wsgi_app是经过封装的，就是Middleware实例对象
            app.wsgi_app = Middleware(app.wsgi_app)
            app.run()
            app.__call__()
            self.wsgi_app(*args,**kwargs)  # 实例对象()执行__call__ 

十一，特殊的装饰器

# 特殊的装饰器
    # 注意被装饰器装饰后的函数名问题
    @app.before_request  # 相当于process_request
    @app.before_first_request  # 只在第一次访问的时候触发 
    @app.after_request  # 相当于process_response
    @app.template_gloal() # 全局模板替换
       {{total(1, 1)}} 

    @app.template_filter()  # 类似django的filter
       {{"hello" | db()}}

    @app.errorhandler(404)  # 当前404时触发

    # 注意执行
    # before_request有返回值的时候还会按顺序执行after_request
    # django 的 <=1.9版本 当process_request有返回值的时候，跟flask是一样的

　　使用自定义装饰器实现 认证功能

import functools

def auth(func)
    @functools.wraps(func)  # endpoint 默认为视图名，不修复的话，别名默认都指向inner
    def inner(*args,**kwargs)
        return func(*args,**kwargs)
    return inner

十二，蓝图

主要功能: 做目录结构,解耦
        1.新建一个项目目录 项目目录下建一个同名的python包
        2.在项目目录下建manager.py
            导入create_app
            app = create_app()
            app.run()
        3.在包的__init__实例化Flask对象
            def create_app():
                把蓝图对象注册到app中
                app.register_blueprint(userBlue,**option)
                app = Flask(__name__)
                return app
        4.在manager.py 导入app app.run()
        5.在Python包里建立views文件夹
            任何一个文件都可以生成蓝图对象
            from flask import Blueprint
            bookBule = BluePrint("bookBlue",__name__)
            @bookBlue.route("/")
            def index():
                return "xxx"-- python项目目录
            -- views目录
                -- user.py
                -- book.py
            -- 同名的py包
                -- __init__ 实例化Flask对象
                -- app.py
        -- manager.py 启动项目
            -- 导入app app.run()

十三，Flask的上下文管理(可以简单的理解为一个请求的生命周期)

　　Flask的上下文管理我们可以简单的理解为一个生命周期，也就是请求进来到请求出去一共做了哪些事情，我们从源码开始走。

　　准备知识

#  偏函数
        from functools import partial
        给一个函数固定一个参数
        def func(x,y,z):
            pass

        new_func = partial(函数名func，固定的参数)
        new_func(x,y) --> func(固定的参数,x,y)

#   __setattr__
        对象.xxx --> __getattr__
        对象.xxx = ""  -->  __setattr__
        当我们实例化的时候先走__init__
            如果在__init__  执行self.xxx = {} 也会走__setattr__

　　Flask的上下文管理(源码分析)

# 请求来的时候究竟做了什么？
    app.run()
        # 1. 调用了werkzeug中run_simple() self 为app
        run_simple(host, port, self, **options)
        # 2. 在run_simple会执行self(),也就是self.__call__(),所以会走Flask的__call__方法
        Flask.__call__():
            # 2.1 在Flask类的__call__方法执行了wsgi_app()方法
            return self.wsgi_app(environ, start_response) # environ是请求的原始数据,start_response为封装的响应对象
            # 2.2 在wsgi_app中，将environ作为参数传给了request_context方法
            ctx = self.request_context(environ)
                # 2.2.1 request_context的返回值为RequestContext, ctx被赋值为 RequestContext的实例对象
                return RequestContext(self, environ) # self为app,执行RequestContext的__init__方法
                # 2.2.2 在RequestContext的__init__方法中,封装了ctx.request和ctx.session,还有ctx.app
                self.app = app
                if request is None:  # 由于request参数没传值默认为None
                    request = app.request_class(environ)
                self.request = request
                # 2.2.3 ctx.session = None
                self.session = None
                # request_class 的真身为Request类
                request_class = Request
                # 2.2.4 相对于ctx.request = Request(environ) 被封装为Request的实例对象
            # 2.3 ctx继续执行了RequestContext类的push()方法
            ctx.push()

　　在ctx.push()　　

　　　　请求的上下文管理　　

# 请求上下文管理
    # 2.3.1 在push方法中 _request_ctx_stack真身为LocalStack的实例对象
    # 相当与执行了 LocalStack().push(ctx)
    _request_ctx_stack.push(self)
        # 2.3.1.1 LocalStack类中的__init__方法
        self._local = Local()
        # 2.3.1.2 Local类的中__init__方法,
        #  封装了 self.__storage__ = {}
        object.__setattr__(self, '__storage__', {})
        #  封装了一个获取线程或协程唯一标识的方法：self.__ident_func__ -> get_ident
        object.__setattr__(self, '__ident_func__', get_ident)
    # 2.3.2 LocalStack类中的push方法
    def push(self, obj): # obj = ctx
        # 通过getattr,触发Local类的__getattr__方法 =>return self.__storage__[self.__ident_func__()][name] => name = stack,去__storage__中，唯一标识对应的{stack:[]}
        rv = getattr(self._local, 'stack', None)
        if rv is None:  # 第一次调用，rv为none
            # self._local.stack赋值操作触发了local类的__setattr__
            # ident = self.__ident_func__()
            # storage = self.__storage__
            # storage[ident][name] = value
            self._local.stack = rv = []
            # 由于rv和self._local.stack都是指向同一个列表内存地址
        rv.append(obj)  # 相当与在给self._local.__storage__[ident][value].append(ctx)  # 优点是步骤小了
        return rv

　　　　应用的上下文管理

# 应用上下文管理
    # 跟请求上下文用的是两个实例化对象  _app_ctx_stack = LocalStack()
    app_ctx = _app_ctx_stack.top # 也是取 __storage__[唯一标识][stack],没赋值所以为空
    if app_ctx is None or app_ctx.app != self.app:
        # self.app 就是我们Flask实例化对象app
        # app_context() = AppContext()
        # AppContext封装了app以及g
        app_ctx = self.app.app_context()
        # 调用AppContext里的push方法
        # 依然是调用_app_ctx_stack.push方法
        # 这里就和请求上下文一样了
        # _app_ctx_stack.push(self)
        # self._local.stack = rv = []
        # self._local.__storage__[ident]['stack'].append(ctx) # ident 进程或现线程的唯一标识
        app_ctx.push()
    # 总结，我们请求上下文和应用上下文，分别别建立了两个Local对象，两个Local对象数据结构都是一样的，那么请求上下文和应用上下文为什么要分开存放呢
    
    # 源码注释：在我们推送请求上下文之前，我们必须确保是一个应用程序上下文。    

　　　　导入的request到时是怎么实现的

# Flask的上下文管理
    #在我们的视图中上面那种拿request的方法太费劲了，我们需要简单一点的拿到request~~那么我们导入的request跟我们上面拿到的request一定是一样的~~那导入的这个request到底是如何实现的呢
    from flask import request
    # request是LocalProxy类的实例对象，参数是一个偏函数
    request = LocalProxy(partial(_lookup_req_object, 'request'))
    # _lookup_req_object
    top = _request_ctx_stack.top
    # return self._local.stack[-1] # 返回ctx
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    return getattr(top, name)  # 返回 ctx.request
    # LocalProxy的实例化
    def __init__(self, local, name=None): # name没传
        # __slots__ 限制了实例对象的 属性__lacal
        # self._LocalProxy__local = local => 偏函数
        object.__setattr__(self, '_LocalProxy__local', local) # 相当于 self.__local = local
        # self.__name__ = None
        object.__setattr__(self, '__name__', name)
        if callable(local) and not hasattr(local, '__release_local__'):
            # "local" is a callable that is not an instance of Local or
            # LocalManager: mark it as a wrapped function.
            object.__setattr__(self, '__wrapped__', local)
    # 当我们调用request.method等方法的时候就是走的时LocalProxy这个类的__getattr__方法
    return getattr(self._get_current_object(), name) # name => method
    # _get_currnet_object(),由于是调用类内方法，可以直接使用私有变量，所以可以用self.__local取值
    if not hasattr(self.__local, '__release_local__'):
        return self.__local()  # self.__local，引用的就是变形的结果,self._LocalProxy__local ==> 偏函数
    return getattr(self.__local, self.__name__)
    # getattr(self._get_current_object(), name) 相当于去ctx.request.method
    # 就跟我们上面的取值方式一样了,也就是说通过LocalStack方法去Local中取ctx对象,
    # 然后通过getattr 找到ctx.request~~~
    # 也就是说这个LocalProxy就是一个帮助我们取值的代理~让我们的取值变的更加简单
    # 这个代理通过偏函数来绑定参数
    # ctx中封装了request，以及session~只不过到这里我们的session依然是空的

　　　　session的原理

# Session的实现原理
    # 首先请求进来的时候在Local中存放了ctx对象~这个对象里的session是None~~
    # 当我们走完这个_reqeust_cts_stack.push(ctx)后，我们看它走了什么
    if self.session is None:
        # session_interface 赋值为 SecureCookieSessionInterface的实例对象
        session_interface = self.app.session_interface
        self.session = session_interface.open_session(
            self.app, self.request # self=>ctx
        )

        if self.session is None:
            self.session = session_interface.make_null_session(self.app) # 如果cookie为，session被赋值为一个空字典

    # SecureCookieSessionInterface类的open_session方法
    def open_session(self, app, request):
        # s是我们加密解密方法
        s = self.get_signing_serializer(app)
        if s is None:
            return None
        # 从cookie中获取数据
        val = request.cookies.get(app.session_cookie_name)
        if not val:
            return self.session_class()
        # 获取配置信息的超时时间
        max_age = total_seconds(app.permanent_session_lifetime)
        try:
            # 解密cookie
            data = s.loads(val, max_age=max_age)
            # 把解密号的数据转成字典返回赋值给了ctx.session
            return self.session_class(data)
        except BadSignature:
            return self.session_class()

    # 请求进来把ctx放入Local中后,从前端解密了cookie,然后把解密数据好的数据给了self.session
    response = self.full_dispatch_request()
    # full_dispatch_request() 中执行了finalize_request
    return self.finalize_request(rv)
    # finalize_request方法中与session有关的关键代码
    response = self.process_response(response)
    # process_response方法中调用了save_session
    if not self.session_interface.is_null_session(ctx.session):  # 相当于判断前端是否有传cookie
        self.session_interface.save_session(self, ctx.session, response)
    # save_session方法执行了设置cookie操作
    response.set_cookie(
        app.session_cookie_name,
        val,
        expires=expires,
        httponly=httponly,
        domain=domain,
        path=path,
        secure=secure,
        samesite=samesite
    )
    # 总结:从cookie中获取数据~解密存入session，请求走的时候，把session中数据取出来，加密， 给响应设置cookie
    # 那么我们平时在视图中设置删除session的值~原来跟request是一样的，通过代理去修改Local中的数据

　　　　g对象

# 在应用上下文封装了g对象，那么这个g对象到底是什么
    请求进来会为每个请求在Local中建立一个独立空间，也就是在应用上下文的Local对象中建立了一个g对象，当请求走的时候，就会删除
    g对象一般情况用于before_request中设置值，只为这一次请求建立全局变量
    g的生命周期是请求进来到走

# 注意：在我们重定向的时候还可以取g的值

对比session和全局变量
    全局变量：是在项目启动创建的，无论多少请求进来都可以访问全局变量
    session：保存在cookie中，所以下次请求来的时候cookie中还会带着数据

　　一个demo

# demo
from flask import Flask, request, session, g, current_app
from flask.globals import _request_ctx_stack


app = Flask(__name__)


@app.before_request
def auth():
    g.xxx = "alex"


@app.route("/")
def index():
    ctx = _request_ctx_stack.top # 取ctx对象
    # ctx.request
    print(ctx.request.method) # 跟request.method一样
    print(current_app) # 返回ctx.app 就是当前的app => flask的实例对象
    # request.method
    # request --> LocalProxy(偏函数)
    # request.xxx --> LocalProxy  __getattr__
    # __getattr__  --> getattr(偏函数的执行，xxx )
    # 偏函数-->  _request_ctx_stack.top.request

    # g.xxx = "nezha"
    print(g.xxx)
    return "INDEX"

@app.route("/user")
def user():
    # print(g.xxx)
    return "USER~~"


if __name__ == '__main__':
    app.run()